dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428 #include <dali/devel-api/events/key-event-devel.h>
 429
 430 #include <dali/public-api/math/matrix.h>
 431 #include <dali/public-api/math/matrix3.h>
 432 #include <dali/public-api/math/viewport.h>
 433 #include <dali/public-api/object/property-key.h>
 434 #include <dali/devel-api/object/csharp-type-info.h>
 435 #include <dali/devel-api/object/csharp-type-registry.h>
 436
 437 #include <dali/public-api/adaptor-framework/timer.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 440
 441 #include <dali/devel-api/images/nine-patch-image.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 456
 457 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 458 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 459 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 460
 461 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 463 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 464
 465 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 466 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 467 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 468
 469 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 470
 471 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 472 #include <dali/devel-api/adaptor-framework/image-loading.h>
 473
 474 #include <dali/public-api/events/mouse-button.h>
 475
 476 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 477 #include "web-view-signal-converter.h"
 478
 479 #include <dali/integration-api/debug.h>
 480
 481 // add here SWIG version check
 482
 483 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 484 // disable Swig-dependent warnings
 485
 486 // 'identifier1' has C-linkage specified,
 487 // but returns UDT 'identifier2' which is incompatible with C
 488 #pragma warning(disable: 4190)
 489
 490 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 491 #pragma warning(disable: 4800)
 492
 493 // debug info too long etc etc
 494 #pragma warning(disable: 4786)
 495 #endif
 496
 497
 498 #include <stdexcept>
 499
 500
 501 #include <string>
 502
 503
 504 #include <vector>
 505 #include <algorithm>
 506 #include <stdexcept>
 507
 508
 509 #include <map>
 510 #include <algorithm>
 511 #include <stdexcept>
 512
 513
 514 #include <utility>
 515
 516
 517 typedef float floatp;
 518
 519 SWIGINTERN floatp *new_floatp(){
 520   return new float();
 521 }
 522 SWIGINTERN void delete_floatp(floatp *self){
 523   if (self) delete self;
 524 }
 525 SWIGINTERN void floatp_assign(floatp *self,float value){
 526   *self = value;
 527 }
 528 SWIGINTERN float floatp_value(floatp *self){
 529   return *self;
 530 }
 531 SWIGINTERN float *floatp_cast(floatp *self){
 532   return self;
 533 }
 534 SWIGINTERN floatp *floatp_frompointer(float *t){
 535   return (floatp *) t;
 536 }
 537
 538 typedef int intp;
 539
 540 SWIGINTERN intp *new_intp(){
 541   return new int();
 542 }
 543 SWIGINTERN void delete_intp(intp *self){
 544   if (self) delete self;
 545 }
 546 SWIGINTERN void intp_assign(intp *self,int value){
 547   *self = value;
 548 }
 549 SWIGINTERN int intp_value(intp *self){
 550   return *self;
 551 }
 552 SWIGINTERN int *intp_cast(intp *self){
 553   return self;
 554 }
 555 SWIGINTERN intp *intp_frompointer(int *t){
 556   return (intp *) t;
 557 }
 558
 559 typedef double doublep;
 560
 561 SWIGINTERN doublep *new_doublep(){
 562   return new double();
 563 }
 564 SWIGINTERN void delete_doublep(doublep *self){
 565   if (self) delete self;
 566 }
 567 SWIGINTERN void doublep_assign(doublep *self,double value){
 568   *self = value;
 569 }
 570 SWIGINTERN double doublep_value(doublep *self){
 571   return *self;
 572 }
 573 SWIGINTERN double *doublep_cast(doublep *self){
 574   return self;
 575 }
 576 SWIGINTERN doublep *doublep_frompointer(double *t){
 577   return (doublep *) t;
 578 }
 579
 580 typedef unsigned int uintp;
 581
 582 SWIGINTERN uintp *new_uintp(){
 583   return new unsigned int();
 584 }
 585 SWIGINTERN void delete_uintp(uintp *self){
 586   if (self) delete self;
 587 }
 588 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 589   *self = value;
 590 }
 591 SWIGINTERN unsigned int uintp_value(uintp *self){
 592   return *self;
 593 }
 594 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 595   return self;
 596 }
 597 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 598   return (uintp *) t;
 599 }
 600
 601 typedef unsigned short ushortp;
 602
 603 SWIGINTERN ushortp *new_ushortp(){
 604   return new unsigned short();
 605 }
 606 SWIGINTERN void delete_ushortp(ushortp *self){
 607   if (self) delete self;
 608 }
 609 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 610   *self = value;
 611 }
 612 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 613   return *self;
 614 }
 615 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 616   return self;
 617 }
 618 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 619   return (ushortp *) t;
 620 }
 621
 622 unsigned int int_to_uint(int x) {
 623    return (unsigned int) x;
 624 }
 625
 626
 627 using namespace Dali;
 628 using namespace Dali::Toolkit;
 629
 630 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 631 {
 632   bool result = false;
 633   try
 634   {
 635     // C++ code. DALi uses Handle <-> Body design pattern.
 636     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 637     // Handles in DALi can be converted into a boolean type
 638     // to check if the handle has a valid body attached to it.
 639     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 640     if( *self )
 641     {
 642       result = true;
 643     }
 644     else
 645     {
 646       result = false;
 647     }
 648   }
 649   catch (std::out_of_range& e)
 650   {
 651     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 652     return 0;
 653   }
 654   catch (std::exception& e)
 655   {
 656     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 657     return 0;
 658   }
 659   catch (DaliException e)
 660   {
 661     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 662     return 0;
 663   }
 664   catch (...)
 665   {
 666     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 667     return 0;
 668   }
 669   return result;
 670 }
 671
 672 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 673 {
 674   bool result = false;
 675   try
 676   {
 677     // C++ code. Check if two handles reference the same implemtion
 678     if( *self == rhs)
 679     {
 680       result = true;
 681     }
 682     else
 683     {
 684       result = false;
 685     }
 686   }
 687   catch (std::out_of_range& e)
 688   {
 689     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 690     return 0;
 691   }
 692   catch (std::exception& e)
 693   {
 694     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 695     return 0;
 696   }
 697   catch (DaliException e)
 698   {
 699     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 700     return 0;
 701   }
 702   catch (...)
 703   {
 704     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 705     return 0;
 706   }
 707   return result;
 708 }
 709
 710
 711 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 712      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 713    }
 714 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 715      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 716    }
 717 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 718         std::vector< Dali::TouchPoint >* pv = 0;
 719         if (capacity >= 0) {
 720           pv = new std::vector< Dali::TouchPoint >();
 721           pv->reserve(capacity);
 722        } else {
 723           throw std::out_of_range("capacity");
 724        }
 725        return pv;
 726       }
 727 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 728         if (index>=0 && index<(int)self->size())
 729           return (*self)[index];
 730         else
 731           throw std::out_of_range("index");
 732       }
 733 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 734         if (index>=0 && index<(int)self->size())
 735           return (*self)[index];
 736         else
 737           throw std::out_of_range("index");
 738       }
 739 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 740         if (index>=0 && index<(int)self->size())
 741           (*self)[index] = val;
 742         else
 743           throw std::out_of_range("index");
 744       }
 745 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 746         self->insert(self->end(), values.begin(), values.end());
 747       }
 748 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 749         if (index < 0)
 750           throw std::out_of_range("index");
 751         if (count < 0)
 752           throw std::out_of_range("count");
 753         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 754           throw std::invalid_argument("invalid range");
 755         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 756       }
 757 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 758         if (index>=0 && index<(int)self->size()+1)
 759           self->insert(self->begin()+index, x);
 760         else
 761           throw std::out_of_range("index");
 762       }
 763 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 764         if (index>=0 && index<(int)self->size()+1)
 765           self->insert(self->begin()+index, values.begin(), values.end());
 766         else
 767           throw std::out_of_range("index");
 768       }
 769 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 770         if (index>=0 && index<(int)self->size())
 771           self->erase(self->begin() + index);
 772         else
 773           throw std::out_of_range("index");
 774       }
 775 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 776         if (index < 0)
 777           throw std::out_of_range("index");
 778         if (count < 0)
 779           throw std::out_of_range("count");
 780         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 781           throw std::invalid_argument("invalid range");
 782         self->erase(self->begin()+index, self->begin()+index+count);
 783       }
 784 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 785         if (count < 0)
 786           throw std::out_of_range("count");
 787         return new std::vector< Dali::TouchPoint >(count, value);
 788       }
 789 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 790         std::reverse(self->begin(), self->end());
 791       }
 792 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 793         if (index < 0)
 794           throw std::out_of_range("index");
 795         if (count < 0)
 796           throw std::out_of_range("count");
 797         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 798           throw std::invalid_argument("invalid range");
 799         std::reverse(self->begin()+index, self->begin()+index+count);
 800       }
 801 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 802         if (index < 0)
 803           throw std::out_of_range("index");
 804         if (index+values.size() > self->size())
 805           throw std::out_of_range("index");
 806         std::copy(values.begin(), values.end(), self->begin()+index);
 807       }
 808 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 809          return self->Empty();
 810       }
 811 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 812         return self->GetConnectionCount();
 813       }
 814 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 815           self->Connect( func );
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 818           self->Disconnect( func );
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 821           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 822 /*@SWIG@*/ self->Emit( arg );
 823       }
 824 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 825          return self->Empty();
 826       }
 827 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 828         return self->GetConnectionCount();
 829       }
 830 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 831           self->Connect( func );
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 834           self->Disconnect( func );
 835       }
 836 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 837           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 838 /*@SWIG@*/ self->Emit( arg );
 839       }
 840 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 841          return self->Empty();
 842       }
 843 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 844         return self->GetConnectionCount();
 845       }
 846 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 847           self->Connect( func );
 848       }
 849 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 850           self->Disconnect( func );
 851       }
 852 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 853           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 854 /*@SWIG@*/ self->Emit( arg );
 855       }
 856 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 857          return self->Empty();
 858       }
 859 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 860         return self->GetConnectionCount();
 861       }
 862 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 863           self->Connect( func );
 864       }
 865 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 866           self->Disconnect( func );
 867       }
 868 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 869           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 870 /*@SWIG@*/ self->Emit( arg );
 871       }
 872 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 873          return self->Empty();
 874       }
 875 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 876         return self->GetConnectionCount();
 877       }
 878 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 879           self->Connect( func );
 880       }
 881 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 882           self->Disconnect( func );
 883       }
 884 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 885           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 886 /*@SWIG@*/ self->Emit( arg );
 887       }
 888 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 889          return self->Empty();
 890       }
 891 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 892         return self->GetConnectionCount();
 893       }
 894 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 895         self->Connect( func );
 896       }
 897 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 898         self->Disconnect( func );
 899       }
 900 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 901         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 902 /*@SWIG@*/ self->Emit( arg1, arg2 );
 903       }
 904 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 905          return self->Empty();
 906       }
 907 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 908         return self->GetConnectionCount();
 909       }
 910 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 911         self->Connect( func );
 912       }
 913 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 914         self->Disconnect( func );
 915       }
 916 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 917         return self->Emit( arg1, arg2 );
 918       }
 919 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 920          return self->Empty();
 921       }
 922 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 923         return self->GetConnectionCount();
 924       }
 925 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 926         self->Connect( func );
 927       }
 928 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 929         self->Disconnect( func );
 930       }
 931 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 932         return self->Emit( arg1, arg2 );
 933       }
 934 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 935          return self->Empty();
 936       }
 937 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 938         return self->GetConnectionCount();
 939       }
 940 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 941         self->Connect( func );
 942       }
 943 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 944         self->Disconnect( func );
 945       }
 946 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 947         return self->Emit( arg1, arg2 );
 948       }
 949 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 950          return self->Empty();
 951       }
 952 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 953         return self->GetConnectionCount();
 954       }
 955 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 956           self->Connect( func );
 957       }
 958 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 959           self->Disconnect( func );
 960       }
 961 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 962           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 963 /*@SWIG@*/ self->Emit( arg );
 964       }
 965 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 966          return self->Empty();
 967       }
 968 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 969         return self->GetConnectionCount();
 970       }
 971 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 972           self->Connect( func );
 973       }
 974 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 975           self->Disconnect( func );
 976       }
 977 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 978           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 979 /*@SWIG@*/ self->Emit( arg );
 980       }
 981 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 982          return self->Empty();
 983       }
 984 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 985         return self->GetConnectionCount();
 986       }
 987 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 988           self->Connect( func );
 989       }
 990 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 991           self->Disconnect( func );
 992       }
 993 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 994           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 995 /*@SWIG@*/ self->Emit( arg );
 996       }
 997 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 998          return self->Empty();
 999       }
1000 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
1001         return self->GetConnectionCount();
1002       }
1003 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1004           self->Connect( func );
1005       }
1006 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1007           self->Disconnect( func );
1008       }
1009 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
1010           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1011 /*@SWIG@*/ self->Emit( arg );
1012       }
1013 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1014          return self->Empty();
1015       }
1016 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1017         return self->GetConnectionCount();
1018       }
1019 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1020         self->Connect( func );
1021       }
1022 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1023         self->Disconnect( func );
1024       }
1025 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
1026         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1027 /*@SWIG@*/ self->Emit( arg1, arg2 );
1028       }
1029 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1030          return self->Empty();
1031       }
1032 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1033         return self->GetConnectionCount();
1034       }
1035 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1036         self->Connect( func );
1037       }
1038 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1039         self->Disconnect( func );
1040       }
1041 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
1042         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1043 /*@SWIG@*/ self->Emit( arg1, arg2 );
1044       }
1045 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1046          return self->Empty();
1047       }
1048 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1049         return self->GetConnectionCount();
1050       }
1051 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1052         self->Connect( func );
1053       }
1054 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1055         self->Disconnect( func );
1056       }
1057 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
1058         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1059 /*@SWIG@*/ self->Emit( arg1, arg2 );
1060       }
1061 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1062          return self->Empty();
1063       }
1064 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1065         return self->GetConnectionCount();
1066       }
1067 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1068           self->Connect( func );
1069       }
1070 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1071           self->Disconnect( func );
1072       }
1073 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1074           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1075 /*@SWIG@*/ self->Emit( arg );
1076       }
1077 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1078          return self->Empty();
1079       }
1080 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1081         return self->GetConnectionCount();
1082       }
1083 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1084           return self->Connect( func );
1085       }
1086 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1087           self->Disconnect( func );
1088       }
1089 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
1090           self->Emit( arg1, arg3 );
1091       }
1092 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1093          return self->Empty();
1094       }
1095 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1096         return self->GetConnectionCount();
1097       }
1098 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1099           return self->Connect( func );
1100       }
1101 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1102           self->Disconnect( func );
1103       }
1104 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1105           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1106 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1107       }
1108
1109 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1110          return self->Empty();
1111       }
1112 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1113         return self->GetConnectionCount();
1114       }
1115 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1116           self->Connect( func );
1117       }
1118 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1119           self->Disconnect( func );
1120       }
1121 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1122           return self->Emit();
1123       }
1124
1125 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1126         std::vector< unsigned int >* pv = 0;
1127         if (capacity >= 0) {
1128           pv = new std::vector< unsigned int >();
1129           pv->reserve(capacity);
1130        } else {
1131           throw std::out_of_range("capacity");
1132        }
1133        return pv;
1134       }
1135 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1136         if (index>=0 && index<(int)self->size())
1137           return (*self)[index];
1138         else
1139           throw std::out_of_range("index");
1140       }
1141 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1142         if (index>=0 && index<(int)self->size())
1143           return (*self)[index];
1144         else
1145           throw std::out_of_range("index");
1146       }
1147 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1148         if (index>=0 && index<(int)self->size())
1149           (*self)[index] = val;
1150         else
1151           throw std::out_of_range("index");
1152       }
1153 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1154         self->insert(self->end(), values.begin(), values.end());
1155       }
1156 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1157         if (index < 0)
1158           throw std::out_of_range("index");
1159         if (count < 0)
1160           throw std::out_of_range("count");
1161         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1162           throw std::invalid_argument("invalid range");
1163         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1164       }
1165 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1166         if (index>=0 && index<(int)self->size()+1)
1167           self->insert(self->begin()+index, x);
1168         else
1169           throw std::out_of_range("index");
1170       }
1171 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1172         if (index>=0 && index<(int)self->size()+1)
1173           self->insert(self->begin()+index, values.begin(), values.end());
1174         else
1175           throw std::out_of_range("index");
1176       }
1177 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1178         if (index>=0 && index<(int)self->size())
1179           self->erase(self->begin() + index);
1180         else
1181           throw std::out_of_range("index");
1182       }
1183 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1184         if (index < 0)
1185           throw std::out_of_range("index");
1186         if (count < 0)
1187           throw std::out_of_range("count");
1188         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1189           throw std::invalid_argument("invalid range");
1190         self->erase(self->begin()+index, self->begin()+index+count);
1191       }
1192 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1193         if (count < 0)
1194           throw std::out_of_range("count");
1195         return new std::vector< unsigned int >(count, value);
1196       }
1197 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1198         std::reverse(self->begin(), self->end());
1199       }
1200 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1201         if (index < 0)
1202           throw std::out_of_range("index");
1203         if (count < 0)
1204           throw std::out_of_range("count");
1205         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1206           throw std::invalid_argument("invalid range");
1207         std::reverse(self->begin()+index, self->begin()+index+count);
1208       }
1209 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1210         if (index < 0)
1211           throw std::out_of_range("index");
1212         if (index+values.size() > self->size())
1213           throw std::out_of_range("index");
1214         std::copy(values.begin(), values.end(), self->begin()+index);
1215       }
1216 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1217         return std::find(self->begin(), self->end(), value) != self->end();
1218       }
1219 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1220         int index = -1;
1221         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1222         if (it != self->end())
1223           index = (int)(it - self->begin());
1224         return index;
1225       }
1226 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1227         int index = -1;
1228         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1229         if (rit != self->rend())
1230           index = (int)(self->rend() - 1 - rit);
1231         return index;
1232       }
1233 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1234         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1235         if (it != self->end()) {
1236           self->erase(it);
1237           return true;
1238         }
1239         return false;
1240       }
1241 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1242         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1243         if (capacity >= 0) {
1244           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1245           pv->reserve(capacity);
1246        } else {
1247           throw std::out_of_range("capacity");
1248        }
1249        return pv;
1250       }
1251 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1252         if (index>=0 && index<(int)self->size())
1253           return (*self)[index];
1254         else
1255           throw std::out_of_range("index");
1256       }
1257 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1258         if (index>=0 && index<(int)self->size())
1259           return (*self)[index];
1260         else
1261           throw std::out_of_range("index");
1262       }
1263 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1264         if (index>=0 && index<(int)self->size())
1265           (*self)[index] = val;
1266         else
1267           throw std::out_of_range("index");
1268       }
1269 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1270         self->insert(self->end(), values.begin(), values.end());
1271       }
1272 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1273         if (index < 0)
1274           throw std::out_of_range("index");
1275         if (count < 0)
1276           throw std::out_of_range("count");
1277         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1278           throw std::invalid_argument("invalid range");
1279         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1280       }
1281 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1282         if (index>=0 && index<(int)self->size()+1)
1283           self->insert(self->begin()+index, x);
1284         else
1285           throw std::out_of_range("index");
1286       }
1287 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1288         if (index>=0 && index<(int)self->size()+1)
1289           self->insert(self->begin()+index, values.begin(), values.end());
1290         else
1291           throw std::out_of_range("index");
1292       }
1293 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1294         if (index>=0 && index<(int)self->size())
1295           self->erase(self->begin() + index);
1296         else
1297           throw std::out_of_range("index");
1298       }
1299 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1300         if (index < 0)
1301           throw std::out_of_range("index");
1302         if (count < 0)
1303           throw std::out_of_range("count");
1304         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1305           throw std::invalid_argument("invalid range");
1306         self->erase(self->begin()+index, self->begin()+index+count);
1307       }
1308 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1309         if (count < 0)
1310           throw std::out_of_range("count");
1311         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1312       }
1313 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1314         std::reverse(self->begin(), self->end());
1315       }
1316 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1317         if (index < 0)
1318           throw std::out_of_range("index");
1319         if (count < 0)
1320           throw std::out_of_range("count");
1321         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1322           throw std::invalid_argument("invalid range");
1323         std::reverse(self->begin()+index, self->begin()+index+count);
1324       }
1325 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1326         if (index < 0)
1327           throw std::out_of_range("index");
1328         if (index+values.size() > self->size())
1329           throw std::out_of_range("index");
1330         std::copy(values.begin(), values.end(), self->begin()+index);
1331       }
1332 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1333         std::vector< Dali::Actor >* pv = 0;
1334         if (capacity >= 0) {
1335           pv = new std::vector< Dali::Actor >();
1336           pv->reserve(capacity);
1337        } else {
1338           throw std::out_of_range("capacity");
1339        }
1340        return pv;
1341       }
1342 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1343         if (index>=0 && index<(int)self->size())
1344           return (*self)[index];
1345         else
1346           throw std::out_of_range("index");
1347       }
1348 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1349         if (index>=0 && index<(int)self->size())
1350           return (*self)[index];
1351         else
1352           throw std::out_of_range("index");
1353       }
1354 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1355         if (index>=0 && index<(int)self->size())
1356           (*self)[index] = val;
1357         else
1358           throw std::out_of_range("index");
1359       }
1360 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1361         self->insert(self->end(), values.begin(), values.end());
1362       }
1363 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1364         if (index < 0)
1365           throw std::out_of_range("index");
1366         if (count < 0)
1367           throw std::out_of_range("count");
1368         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1369           throw std::invalid_argument("invalid range");
1370         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1371       }
1372 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1373         if (index>=0 && index<(int)self->size()+1)
1374           self->insert(self->begin()+index, x);
1375         else
1376           throw std::out_of_range("index");
1377       }
1378 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1379         if (index>=0 && index<(int)self->size()+1)
1380           self->insert(self->begin()+index, values.begin(), values.end());
1381         else
1382           throw std::out_of_range("index");
1383       }
1384 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1385         if (index>=0 && index<(int)self->size())
1386           self->erase(self->begin() + index);
1387         else
1388           throw std::out_of_range("index");
1389       }
1390 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1391         if (index < 0)
1392           throw std::out_of_range("index");
1393         if (count < 0)
1394           throw std::out_of_range("count");
1395         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1396           throw std::invalid_argument("invalid range");
1397         self->erase(self->begin()+index, self->begin()+index+count);
1398       }
1399 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1400         if (count < 0)
1401           throw std::out_of_range("count");
1402         return new std::vector< Dali::Actor >(count, value);
1403       }
1404 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1405         std::reverse(self->begin(), self->end());
1406       }
1407 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1408         if (index < 0)
1409           throw std::out_of_range("index");
1410         if (count < 0)
1411           throw std::out_of_range("count");
1412         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1413           throw std::invalid_argument("invalid range");
1414         std::reverse(self->begin()+index, self->begin()+index+count);
1415       }
1416 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1417         if (index < 0)
1418           throw std::out_of_range("index");
1419         if (index+values.size() > self->size())
1420           throw std::out_of_range("index");
1421         std::copy(values.begin(), values.end(), self->begin()+index);
1422       }
1423 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1424          return self->Empty();
1425       }
1426 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1427         return self->GetConnectionCount();
1428       }
1429 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1430           self->Connect( func );
1431       }
1432 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1433           self->Disconnect( func );
1434       }
1435 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1436           return self->Emit( arg );
1437       }
1438 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1439          return self->Empty();
1440       }
1441 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1442         return self->GetConnectionCount();
1443       }
1444 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1445         self->Connect( func );
1446       }
1447 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1448         self->Disconnect( func );
1449       }
1450 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1451         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1452 /*@SWIG@*/ self->Emit( arg1, arg2 );
1453       }
1454 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1455          return self->Empty();
1456       }
1457 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1458         return self->GetConnectionCount();
1459       }
1460 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1461         self->Connect( func );
1462       }
1463 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1464         self->Disconnect( func );
1465       }
1466 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1467         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1468 /*@SWIG@*/ self->Emit( arg1, arg2 );
1469       }
1470 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1471          return self->Empty();
1472       }
1473 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1474         return self->GetConnectionCount();
1475       }
1476 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1477         self->Connect( func );
1478       }
1479 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1480         self->Disconnect( func );
1481       }
1482 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1483         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1484 /*@SWIG@*/ self->Emit( arg1, arg2 );
1485       }
1486 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1487          return self->Empty();
1488       }
1489 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1490         return self->GetConnectionCount();
1491       }
1492 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1493         self->Connect( func );
1494       }
1495 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1496         self->Disconnect( func );
1497       }
1498 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1499         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1500 /*@SWIG@*/ self->Emit( arg1, arg2 );
1501       }
1502 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1503          return self->Empty();
1504       }
1505 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1506         return self->GetConnectionCount();
1507       }
1508 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1509           self->Connect( func );
1510       }
1511 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1512           self->Disconnect( func );
1513       }
1514 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1515           return self->Emit( arg );
1516       }
1517 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1518          return self->Empty();
1519       }
1520 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1521         return self->GetConnectionCount();
1522       }
1523 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1524           self->Connect( func );
1525       }
1526 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1527           self->Disconnect( func );
1528       }
1529 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1530           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1531 /*@SWIG@*/ self->Emit( arg );
1532       }
1533 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1534          return self->Empty();
1535       }
1536 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1537         return self->GetConnectionCount();
1538       }
1539 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1540           return self->Connect( func );
1541       }
1542 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1543           self->Disconnect( func );
1544       }
1545 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1546           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1547 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1548       }
1549 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1550          return self->Empty();
1551       }
1552 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1553         return self->GetConnectionCount();
1554       }
1555 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1556           self->Connect( func );
1557       }
1558 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1559           self->Disconnect( func );
1560       }
1561 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1562           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1563 /*@SWIG@*/ self->Emit( arg );
1564       }
1565 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1566          return self->Empty();
1567       }
1568 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1569         return self->GetConnectionCount();
1570       }
1571 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1572           return self->Connect( func );
1573       }
1574 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1575           self->Disconnect( func );
1576       }
1577 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1578           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1579 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1580       }
1581 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1582          return self->Empty();
1583       }
1584 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1585         return self->GetConnectionCount();
1586       }
1587 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1588           self->Connect( func );
1589       }
1590 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1591           self->Disconnect( func );
1592       }
1593 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1594           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1595 /*@SWIG@*/ self->Emit( arg );
1596       }
1597 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1598          return self->Empty();
1599       }
1600 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1601         return self->GetConnectionCount();
1602       }
1603 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1604           self->Connect( func );
1605       }
1606 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1607           self->Disconnect( func );
1608       }
1609 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1610           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1611 /*@SWIG@*/ self->Emit( arg );
1612       }
1613
1614
1615 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1616          return self->Empty();
1617       }
1618 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1619         return self->GetConnectionCount();
1620       }
1621 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1622         self->Connect( func );
1623       }
1624 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1625         self->Disconnect( func );
1626       }
1627 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1628         return self->Emit( arg1, arg2 );
1629       }
1630 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1631          return self->Empty();
1632       }
1633 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1634         return self->GetConnectionCount();
1635       }
1636 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1637           self->Connect( func );
1638       }
1639 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1640           self->Disconnect( func );
1641       }
1642 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1643           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1644 /*@SWIG@*/ self->Emit( arg );
1645       }
1646 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1647          return self->Empty();
1648       }
1649 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1650         return self->GetConnectionCount();
1651       }
1652 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1653           self->Connect( func );
1654       }
1655 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1656           self->Disconnect( func );
1657       }
1658 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1659           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1660 /*@SWIG@*/ self->Emit( arg );
1661       }
1662 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1663          return self->Empty();
1664       }
1665 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1666         return self->GetConnectionCount();
1667       }
1668 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1669         self->Connect( func );
1670       }
1671 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1672         self->Disconnect( func );
1673       }
1674 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1675         return self->Emit( arg1, arg2 );
1676       }
1677 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1678          return self->Empty();
1679       }
1680 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1681         return self->GetConnectionCount();
1682       }
1683 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1684         self->Connect( func );
1685       }
1686 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1687         self->Disconnect( func );
1688       }
1689 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1690         return self->Emit( arg1, arg2 );
1691       }
1692
1693 /* ---------------------------------------------------
1694  * C++ director class methods
1695  * --------------------------------------------------- */
1696
1697 #include "dali_wrap.h"
1698
1699 /*
1700  *  Widget director
1701  */
1702 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1703   swig_init_callbacks();
1704 }
1705
1706 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1707 }
1708
1709 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1710   char * jcontentInfo = 0 ;
1711   void * jwindow  ;
1712
1713   if (!swig_callbackOnCreate) {
1714     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1715     return;
1716   } else {
1717     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1718     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1719     swig_callbackOnCreate(jcontentInfo, jwindow);
1720   }
1721 }
1722
1723 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1724   char * jcontentInfo = 0 ;
1725   int jtype  ;
1726
1727   if (!swig_callbackOnTerminate) {
1728     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1729     return;
1730   } else {
1731     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1732     jtype = (int)type;
1733     swig_callbackOnTerminate(jcontentInfo, jtype);
1734   }
1735 }
1736
1737 void SwigDirector_WidgetImpl::OnPause() {
1738   if (!swig_callbackOnPause) {
1739     Dali::Internal::Adaptor::Widget::OnPause();
1740     return;
1741   } else {
1742     swig_callbackOnPause();
1743   }
1744 }
1745
1746 void SwigDirector_WidgetImpl::OnResume() {
1747   if (!swig_callbackOnResume) {
1748     Dali::Internal::Adaptor::Widget::OnResume();
1749     return;
1750   } else {
1751     swig_callbackOnResume();
1752   }
1753 }
1754
1755 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1756   void * jwindow  ;
1757
1758   if (!swig_callbackOnResize) {
1759     Dali::Internal::Adaptor::Widget::OnResize(window);
1760     return;
1761   } else {
1762     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1763     swig_callbackOnResize(jwindow);
1764   }
1765 }
1766
1767 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1768   char * jcontentInfo = 0 ;
1769   int jforce  ;
1770
1771   if (!swig_callbackOnUpdate) {
1772     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1773     return;
1774   } else {
1775     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1776     jforce = force;
1777     swig_callbackOnUpdate(jcontentInfo, jforce);
1778   }
1779 }
1780
1781 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1782   void * jslotObserver = 0 ;
1783   void * jcallback = 0 ;
1784
1785   if (!swig_callbackSignalConnected) {
1786     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1787     return;
1788   } else {
1789     jslotObserver = (void *) slotObserver;
1790     jcallback = (void *) callback;
1791     swig_callbackSignalConnected(jslotObserver, jcallback);
1792   }
1793 }
1794
1795 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1796   void * jslotObserver = 0 ;
1797   void * jcallback = 0 ;
1798
1799   if (!swig_callbackSignalDisconnected) {
1800     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1801     return;
1802   } else {
1803     jslotObserver = (void *) slotObserver;
1804     jcallback = (void *) callback;
1805     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1806   }
1807 }
1808
1809 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1810
1811   swig_callbackOnCreate = callbackOnCreate;
1812   swig_callbackOnTerminate = callbackOnTerminate;
1813   swig_callbackOnPause = callbackOnPause;
1814   swig_callbackOnResume = callbackOnResume;
1815   swig_callbackOnResize = callbackOnResize;
1816   swig_callbackOnUpdate = callbackOnUpdate;
1817   swig_callbackSignalConnected = callbackSignalConnected;
1818   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1819 }
1820
1821 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1822   swig_callbackOnCreate = 0;
1823   swig_callbackOnTerminate = 0;
1824   swig_callbackOnPause = 0;
1825   swig_callbackOnResume = 0;
1826   swig_callbackOnResize = 0;
1827   swig_callbackOnUpdate = 0;
1828   swig_callbackSignalConnected = 0;
1829   swig_callbackSignalDisconnected = 0;
1830 }
1831
1832
1833 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1834   swig_init_callbacks();
1835 }
1836
1837 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1838
1839 }
1840
1841
1842 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1843   int jdepth  ;
1844
1845   if (!swig_callbackOnStageConnection) {
1846     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1847     return;
1848   } else {
1849     jdepth = depth;
1850     swig_callbackOnStageConnection(jdepth);
1851   }
1852 }
1853
1854 void SwigDirector_ViewImpl::OnStageDisconnection() {
1855   if (!swig_callbackOnStageDisconnection) {
1856     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1857     return;
1858   } else {
1859     swig_callbackOnStageDisconnection();
1860   }
1861 }
1862
1863 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1864   void * jchild = 0 ;
1865
1866   if (!swig_callbackOnChildAdd) {
1867     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1868     return;
1869   } else {
1870     jchild = (Dali::Actor *) &child;
1871     swig_callbackOnChildAdd(jchild);
1872   }
1873 }
1874
1875 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1876   void * jchild = 0 ;
1877
1878   if (!swig_callbackOnChildRemove) {
1879     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1880     return;
1881   } else {
1882     jchild = (Dali::Actor *) &child;
1883     swig_callbackOnChildRemove(jchild);
1884   }
1885 }
1886
1887 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1888   int jindex  ;
1889   void * jpropertyValue  ;
1890
1891   if (!swig_callbackOnPropertySet) {
1892     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1893     return;
1894   } else {
1895     jindex = index;
1896     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1897     swig_callbackOnPropertySet(jindex, jpropertyValue);
1898   }
1899 }
1900
1901 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1902   void * jtargetSize = 0 ;
1903
1904   if (!swig_callbackOnSizeSet) {
1905     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1906     return;
1907   } else {
1908     jtargetSize = (Dali::Vector3 *) &targetSize;
1909     swig_callbackOnSizeSet(jtargetSize);
1910   }
1911 }
1912
1913 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1914   void * janimation = 0 ;
1915   void * jtargetSize = 0 ;
1916
1917   if (!swig_callbackOnSizeAnimation) {
1918     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1919     return;
1920   } else {
1921     janimation = (Dali::Animation *) &animation;
1922     jtargetSize = (Dali::Vector3 *) &targetSize;
1923     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1924   }
1925 }
1926
1927 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1928   bool c_result = SwigValueInit< bool >() ;
1929   unsigned int jresult = 0 ;
1930   void * jarg0 = 0 ;
1931
1932   if (!swig_callbackOnTouchEvent) {
1933     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1934   } else {
1935     jarg0 = (Dali::TouchEvent *) &event;
1936     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1937     c_result = jresult ? true : false;
1938   }
1939   return c_result;
1940 }
1941
1942 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1943   bool c_result = SwigValueInit< bool >() ;
1944   unsigned int jresult = 0 ;
1945   void * jarg0 = 0 ;
1946
1947   if (!swig_callbackOnHoverEvent) {
1948     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1949   } else {
1950     jarg0 = (Dali::HoverEvent *) &event;
1951     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1952     c_result = jresult ? true : false;
1953   }
1954   return c_result;
1955 }
1956
1957 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1958   bool c_result = SwigValueInit< bool >() ;
1959   unsigned int jresult = 0 ;
1960   void * jarg0 = 0 ;
1961
1962   if (!swig_callbackOnKeyEvent) {
1963     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1964   } else {
1965     jarg0 = (Dali::KeyEvent *) &event;
1966     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1967     c_result = jresult ? true : false;
1968   }
1969   return c_result;
1970 }
1971
1972 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1973   bool c_result = SwigValueInit< bool >() ;
1974   unsigned int jresult = 0 ;
1975   void * jarg0 = 0 ;
1976
1977   if (!swig_callbackOnWheelEvent) {
1978     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1979   } else {
1980     jarg0 = (Dali::WheelEvent *) &event;
1981     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1982     c_result = jresult ? true : false;
1983   }
1984   return c_result;
1985 }
1986
1987 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1988   void * jsize = 0 ;
1989   void * jcontainer = 0 ;
1990
1991   if (!swig_callbackOnRelayout) {
1992     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1993     return;
1994   } else {
1995     jsize = (Dali::Vector2 *) &size;
1996     jcontainer = (Dali::RelayoutContainer *) &container;
1997     swig_callbackOnRelayout(jsize, jcontainer);
1998   }
1999 }
2000
2001 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
2002   int jpolicy  ;
2003   int jdimension  ;
2004
2005   if (!swig_callbackOnSetResizePolicy) {
2006     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2007     return;
2008   } else {
2009     jpolicy = (int)policy;
2010     jdimension = (int)dimension;
2011     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2012   }
2013 }
2014
2015 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2016   Dali::Vector3 c_result ;
2017   void * jresult = 0 ;
2018
2019   if (!swig_callbackGetNaturalSize) {
2020     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2021   } else {
2022     jresult = (void *) swig_callbackGetNaturalSize();
2023     if (!jresult) {
2024       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2025       return c_result;
2026     }
2027     c_result = *(Dali::Vector3 *)jresult;
2028   }
2029   return c_result;
2030 }
2031
2032 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2033   float c_result = SwigValueInit< float >() ;
2034   float jresult = 0 ;
2035   void * jchild = 0 ;
2036   int jdimension  ;
2037
2038   if (!swig_callbackCalculateChildSize) {
2039     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2040   } else {
2041     jchild = (Dali::Actor *) &child;
2042     jdimension = (int)dimension;
2043     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2044     c_result = (float)jresult;
2045   }
2046   return c_result;
2047 }
2048
2049 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2050   float c_result = SwigValueInit< float >() ;
2051   float jresult = 0 ;
2052   float jwidth  ;
2053
2054   if (!swig_callbackGetHeightForWidth) {
2055     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2056   } else {
2057     jwidth = width;
2058     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2059     c_result = (float)jresult;
2060   }
2061   return c_result;
2062 }
2063
2064 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2065   float c_result = SwigValueInit< float >() ;
2066   float jresult = 0 ;
2067   float jheight  ;
2068
2069   if (!swig_callbackGetWidthForHeight) {
2070     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2071   } else {
2072     jheight = height;
2073     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2074     c_result = (float)jresult;
2075   }
2076   return c_result;
2077 }
2078
2079 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2080   bool c_result = SwigValueInit< bool >() ;
2081   unsigned int jresult = 0 ;
2082   int jdimension  ;
2083
2084   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2085     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2086   } else {
2087     jdimension = (int)dimension;
2088     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2089     c_result = jresult ? true : false;
2090   }
2091   return c_result;
2092 }
2093
2094 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2095   int jdimension  ;
2096
2097   if (!swig_callbackOnCalculateRelayoutSize) {
2098     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2099     return;
2100   } else {
2101     jdimension = (int)dimension;
2102     swig_callbackOnCalculateRelayoutSize(jdimension);
2103   }
2104 }
2105
2106 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2107   float jsize  ;
2108   int jdimension  ;
2109
2110   if (!swig_callbackOnLayoutNegotiated) {
2111     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2112     return;
2113   } else {
2114     jsize = size;
2115     jdimension = (int)dimension;
2116     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2117   }
2118 }
2119
2120 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2121   return Dali::CustomActorImpl::GetExtension();
2122 }
2123
2124 void SwigDirector_ViewImpl::OnInitialize() {
2125   if (!swig_callbackOnInitialize) {
2126     Dali::Toolkit::Internal::Control::OnInitialize();
2127     return;
2128   } else {
2129     swig_callbackOnInitialize();
2130   }
2131 }
2132
2133 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2134   void * jchild = 0 ;
2135
2136   if (!swig_callbackOnControlChildAdd) {
2137     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2138     return;
2139   } else {
2140     jchild = (Dali::Actor *) &child;
2141     swig_callbackOnControlChildAdd(jchild);
2142   }
2143 }
2144
2145 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2146   void * jchild = 0 ;
2147
2148   if (!swig_callbackOnControlChildRemove) {
2149     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2150     return;
2151   } else {
2152     jchild = (Dali::Actor *) &child;
2153     swig_callbackOnControlChildRemove(jchild);
2154   }
2155 }
2156
2157 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2158   void * jstyleManager  ;
2159   int jchange  ;
2160
2161   if (!swig_callbackOnStyleChange) {
2162     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2163     return;
2164   } else {
2165     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2166     jchange = (int)change;
2167     swig_callbackOnStyleChange(jstyleManager, jchange);
2168   }
2169 }
2170
2171 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2172   bool c_result = SwigValueInit< bool >() ;
2173   unsigned int jresult = 0 ;
2174
2175   if (!swig_callbackOnAccessibilityActivated) {
2176     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2177   } else {
2178     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2179     c_result = jresult ? true : false;
2180   }
2181   return c_result;
2182 }
2183
2184 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2185   bool c_result = SwigValueInit< bool >() ;
2186   unsigned int jresult = 0 ;
2187   void * jgesture  ;
2188
2189   if (!swig_callbackOnAccessibilityPan) {
2190     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2191   } else {
2192     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2193     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2194     c_result = jresult ? true : false;
2195   }
2196   return c_result;
2197 }
2198
2199 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2200   bool c_result = SwigValueInit< bool >() ;
2201   unsigned int jresult = 0 ;
2202   void * jtouchEvent = 0 ;
2203
2204   if (!swig_callbackOnAccessibilityTouch) {
2205     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2206   } else {
2207     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2208     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2209     c_result = jresult ? true : false;
2210   }
2211   return c_result;
2212 }
2213
2214 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2215   bool c_result = SwigValueInit< bool >() ;
2216   unsigned int jresult = 0 ;
2217   unsigned int jisIncrease  ;
2218
2219   if (!swig_callbackOnAccessibilityValueChange) {
2220     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2221   } else {
2222     jisIncrease = isIncrease;
2223     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2224     c_result = jresult ? true : false;
2225   }
2226   return c_result;
2227 }
2228
2229 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2230   bool c_result = SwigValueInit< bool >() ;
2231   unsigned int jresult = 0 ;
2232
2233   if (!swig_callbackOnAccessibilityZoom) {
2234     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2235   } else {
2236     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2237     c_result = jresult ? true : false;
2238   }
2239   return c_result;
2240 }
2241
2242 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2243   if (!swig_callbackOnKeyInputFocusGained) {
2244     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2245     return;
2246   } else {
2247     swig_callbackOnKeyInputFocusGained();
2248   }
2249 }
2250
2251 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2252   if (!swig_callbackOnKeyInputFocusLost) {
2253     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2254     return;
2255   } else {
2256     swig_callbackOnKeyInputFocusLost();
2257   }
2258 }
2259
2260 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2261   Dali::Actor c_result ;
2262   void * jresult = 0 ;
2263   void * jcurrentFocusedActor  ;
2264   int jdirection  ;
2265   unsigned int jloopEnabled  ;
2266
2267   if (!swig_callbackGetNextKeyboardFocusableActor) {
2268     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2269   } else {
2270     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2271     jdirection = (int)direction;
2272     jloopEnabled = loopEnabled;
2273     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2274     if (!jresult) {
2275       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2276       return c_result;
2277     }
2278     c_result = *(Dali::Actor *)jresult;
2279   }
2280   return c_result;
2281 }
2282
2283 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2284   void * jcommitedFocusableActor  ;
2285
2286   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2287     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2288     return;
2289   } else {
2290     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2291     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2292   }
2293 }
2294
2295 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2296   bool c_result = SwigValueInit< bool >() ;
2297   unsigned int jresult = 0 ;
2298
2299   if (!swig_callbackOnKeyboardEnter) {
2300     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2301   } else {
2302     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2303     c_result = jresult ? true : false;
2304   }
2305   return c_result;
2306 }
2307
2308 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2309   void * jpinch = 0 ;
2310
2311   if (!swig_callbackOnPinch) {
2312     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2313     return;
2314   } else {
2315     jpinch = (Dali::PinchGesture *) &pinch;
2316     swig_callbackOnPinch(jpinch);
2317   }
2318 }
2319
2320 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2321   void * jpan = 0 ;
2322
2323   if (!swig_callbackOnPan) {
2324     Dali::Toolkit::Internal::Control::OnPan(pan);
2325     return;
2326   } else {
2327     jpan = (Dali::PanGesture *) &pan;
2328     swig_callbackOnPan(jpan);
2329   }
2330 }
2331
2332 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2333   void * jtap = 0 ;
2334
2335   if (!swig_callbackOnTap) {
2336     Dali::Toolkit::Internal::Control::OnTap(tap);
2337     return;
2338   } else {
2339     jtap = (Dali::TapGesture *) &tap;
2340     swig_callbackOnTap(jtap);
2341   }
2342 }
2343
2344 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2345   void * jlongPress = 0 ;
2346
2347   if (!swig_callbackOnLongPress) {
2348     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2349     return;
2350   } else {
2351     jlongPress = (Dali::LongPressGesture *) &longPress;
2352     swig_callbackOnLongPress(jlongPress);
2353   }
2354 }
2355
2356 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2357   void * jslotObserver = 0 ;
2358   void * jcallback = 0 ;
2359
2360   if (!swig_callbackSignalConnected) {
2361     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2362     return;
2363   } else {
2364     jslotObserver = (void *) slotObserver;
2365     jcallback = (void *) callback;
2366     swig_callbackSignalConnected(jslotObserver, jcallback);
2367   }
2368 }
2369
2370 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2371   void * jslotObserver = 0 ;
2372   void * jcallback = 0 ;
2373
2374   if (!swig_callbackSignalDisconnected) {
2375     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2376     return;
2377   } else {
2378     jslotObserver = (void *) slotObserver;
2379     jcallback = (void *) callback;
2380     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2381   }
2382 }
2383
2384 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2385   return Dali::Toolkit::Internal::Control::GetControlExtension();
2386 }
2387
2388 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2389   swig_callbackOnStageConnection = callbackOnStageConnection;
2390   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2391   swig_callbackOnChildAdd = callbackOnChildAdd;
2392   swig_callbackOnChildRemove = callbackOnChildRemove;
2393   swig_callbackOnPropertySet = callbackOnPropertySet;
2394   swig_callbackOnSizeSet = callbackOnSizeSet;
2395   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2396   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2397   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2398   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2399   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2400   swig_callbackOnRelayout = callbackOnRelayout;
2401   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2402   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2403   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2404   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2405   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2406   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2407   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2408   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2409   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2410   swig_callbackOnInitialize = callbackOnInitialize;
2411   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2412   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2413   swig_callbackOnStyleChange = callbackOnStyleChange;
2414   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2415   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2416   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2417   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2418   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2419   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2420   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2421   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2422   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2423   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2424   swig_callbackOnPinch = callbackOnPinch;
2425   swig_callbackOnPan = callbackOnPan;
2426   swig_callbackOnTap = callbackOnTap;
2427   swig_callbackOnLongPress = callbackOnLongPress;
2428   swig_callbackSignalConnected = callbackSignalConnected;
2429   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2430 }
2431
2432 void SwigDirector_ViewImpl::swig_init_callbacks() {
2433   swig_callbackOnStageConnection = 0;
2434   swig_callbackOnStageDisconnection = 0;
2435   swig_callbackOnChildAdd = 0;
2436   swig_callbackOnChildRemove = 0;
2437   swig_callbackOnPropertySet = 0;
2438   swig_callbackOnSizeSet = 0;
2439   swig_callbackOnSizeAnimation = 0;
2440   swig_callbackOnTouchEvent = 0;
2441   swig_callbackOnHoverEvent = 0;
2442   swig_callbackOnKeyEvent = 0;
2443   swig_callbackOnWheelEvent = 0;
2444   swig_callbackOnRelayout = 0;
2445   swig_callbackOnSetResizePolicy = 0;
2446   swig_callbackGetNaturalSize = 0;
2447   swig_callbackCalculateChildSize = 0;
2448   swig_callbackGetHeightForWidth = 0;
2449   swig_callbackGetWidthForHeight = 0;
2450   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2451   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2452   swig_callbackOnCalculateRelayoutSize = 0;
2453   swig_callbackOnLayoutNegotiated = 0;
2454   swig_callbackOnInitialize = 0;
2455   swig_callbackOnControlChildAdd = 0;
2456   swig_callbackOnControlChildRemove = 0;
2457   swig_callbackOnStyleChange = 0;
2458   swig_callbackOnAccessibilityActivated = 0;
2459   swig_callbackOnAccessibilityPan = 0;
2460   swig_callbackOnAccessibilityTouch = 0;
2461   swig_callbackOnAccessibilityValueChange = 0;
2462   swig_callbackOnAccessibilityZoom = 0;
2463   swig_callbackOnKeyInputFocusGained = 0;
2464   swig_callbackOnKeyInputFocusLost = 0;
2465   swig_callbackGetNextKeyboardFocusableActor = 0;
2466   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2467   swig_callbackOnKeyboardEnter = 0;
2468   swig_callbackOnPinch = 0;
2469   swig_callbackOnPan = 0;
2470   swig_callbackOnTap = 0;
2471   swig_callbackOnLongPress = 0;
2472   swig_callbackSignalConnected = 0;
2473   swig_callbackSignalDisconnected = 0;
2474 }
2475
2476 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2477   swig_init_callbacks();
2478 }
2479
2480 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2481
2482 }
2483
2484
2485 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2486   unsigned int c_result = SwigValueInit< unsigned int >() ;
2487   unsigned int jresult = 0 ;
2488
2489   if (!swig_callbackGetNumberOfItems) {
2490     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2491   } else {
2492     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2493     c_result = (unsigned int)jresult;
2494   }
2495   return c_result;
2496 }
2497
2498 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2499   Dali::Actor c_result ;
2500   void * jresult = 0 ;
2501   unsigned int jitemId  ;
2502
2503   if (!swig_callbackNewItem) {
2504     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2505   } else {
2506     jitemId = itemId;
2507     jresult = (void *) swig_callbackNewItem(jitemId);
2508     if (!jresult) {
2509       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2510       return c_result;
2511     }
2512     c_result = *(Dali::Actor *)jresult;
2513   }
2514   return c_result;
2515 }
2516
2517 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2518   unsigned int jitemId  ;
2519   void * jactor  ;
2520
2521   if (!swig_callbackItemReleased) {
2522     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2523     return;
2524   } else {
2525     jitemId = itemId;
2526     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2527     swig_callbackItemReleased(jitemId, jactor);
2528   }
2529 }
2530
2531 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2532   return Dali::Toolkit::ItemFactory::GetExtension();
2533 }
2534
2535 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2536   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2537   swig_callbackNewItem = callbackNewItem;
2538   swig_callbackItemReleased = callbackItemReleased;
2539 }
2540
2541 void SwigDirector_ItemFactory::swig_init_callbacks() {
2542   swig_callbackGetNumberOfItems = 0;
2543   swig_callbackNewItem = 0;
2544   swig_callbackItemReleased = 0;
2545 }
2546
2547 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2548   swig_init_callbacks();
2549 }
2550
2551 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2552
2553 }
2554
2555
2556 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2557   Dali::Actor c_result ;
2558   void * jresult = 0 ;
2559   void * jcurrent  ;
2560   void * jproposed  ;
2561   int jdirection  ;
2562
2563   if (!swig_callbackGetNextFocusableActor) {
2564     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2565   } else {
2566     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2567     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2568     jdirection = (int)direction;
2569     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2570     if (!jresult) {
2571       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::Actor! Next focus will be NULL, please be cautious to handle the keyboard foucs! ", __FILE__, __LINE__);
2572       return c_result;
2573     }
2574     c_result = *(Dali::Actor *)jresult;
2575   }
2576   return c_result;
2577 }
2578
2579 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2580   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2581 }
2582
2583 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2584   swig_callbackGetNextFocusableActor = 0;
2585 }
2586
2587
2588 #ifdef __cplusplus
2589 extern "C" {
2590 #endif
2591
2592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2593   void * jresult ;
2594   floatp *result = 0 ;
2595
2596   {
2597     try {
2598       result = (floatp *)new_floatp();
2599     } catch (std::out_of_range& e) {
2600       {
2601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2602       };
2603     } catch (std::exception& e) {
2604       {
2605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2606       };
2607     } catch (DaliException e) {
2608       {
2609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2610       };
2611     } catch (...) {
2612       {
2613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2614       };
2615     }
2616   }
2617   jresult = (void *)result;
2618   return jresult;
2619 }
2620
2621
2622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2623   floatp *arg1 = (floatp *) 0 ;
2624
2625   arg1 = (floatp *)jarg1;
2626   {
2627     try {
2628       delete_floatp(arg1);
2629     } catch (std::out_of_range& e) {
2630       {
2631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2632       };
2633     } catch (std::exception& e) {
2634       {
2635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2636       };
2637     } catch (Dali::DaliException e) {
2638       {
2639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2640       };
2641     } catch (...) {
2642       {
2643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2644       };
2645     }
2646   }
2647
2648 }
2649
2650
2651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2652   floatp *arg1 = (floatp *) 0 ;
2653   float arg2 ;
2654
2655   arg1 = (floatp *)jarg1;
2656   arg2 = (float)jarg2;
2657   {
2658     try {
2659       floatp_assign(arg1,arg2);
2660     } catch (std::out_of_range& e) {
2661       {
2662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2663       };
2664     } catch (std::exception& e) {
2665       {
2666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2667       };
2668     } catch (Dali::DaliException e) {
2669       {
2670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2671       };
2672     } catch (...) {
2673       {
2674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2675       };
2676     }
2677   }
2678
2679 }
2680
2681
2682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2683   float jresult ;
2684   floatp *arg1 = (floatp *) 0 ;
2685   float result;
2686
2687   arg1 = (floatp *)jarg1;
2688   {
2689     try {
2690       result = (float)floatp_value(arg1);
2691     } catch (std::out_of_range& e) {
2692       {
2693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2694       };
2695     } catch (std::exception& e) {
2696       {
2697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2698       };
2699     } catch (DaliException e) {
2700       {
2701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2702       };
2703     } catch (...) {
2704       {
2705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2706       };
2707     }
2708   }
2709   jresult = result;
2710   return jresult;
2711 }
2712
2713
2714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2715   void * jresult ;
2716   floatp *arg1 = (floatp *) 0 ;
2717   float *result = 0 ;
2718
2719   arg1 = (floatp *)jarg1;
2720   {
2721     try {
2722       result = (float *)floatp_cast(arg1);
2723     } catch (std::out_of_range& e) {
2724       {
2725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2726       };
2727     } catch (std::exception& e) {
2728       {
2729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2730       };
2731     } catch (Dali::DaliException e) {
2732       {
2733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2734       };
2735     } catch (...) {
2736       {
2737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2738       };
2739     }
2740   }
2741
2742   jresult = (void *)result;
2743   return jresult;
2744 }
2745
2746
2747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2748   void * jresult ;
2749   float *arg1 = (float *) 0 ;
2750   floatp *result = 0 ;
2751
2752   arg1 = (float *)jarg1;
2753   {
2754     try {
2755       result = (floatp *)floatp_frompointer(arg1);
2756     } catch (std::out_of_range& e) {
2757       {
2758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2759       };
2760     } catch (std::exception& e) {
2761       {
2762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2763       };
2764     } catch (Dali::DaliException e) {
2765       {
2766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2767       };
2768     } catch (...) {
2769       {
2770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2771       };
2772     }
2773   }
2774
2775   jresult = (void *)result;
2776   return jresult;
2777 }
2778
2779
2780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2781   void * jresult ;
2782   intp *result = 0 ;
2783
2784   {
2785     try {
2786       result = (intp *)new_intp();
2787     } catch (std::out_of_range& e) {
2788       {
2789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2790       };
2791     } catch (std::exception& e) {
2792       {
2793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2794       };
2795     } catch (Dali::DaliException e) {
2796       {
2797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2798       };
2799     } catch (...) {
2800       {
2801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2802       };
2803     }
2804   }
2805
2806   jresult = (void *)result;
2807   return jresult;
2808 }
2809
2810
2811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2812   intp *arg1 = (intp *) 0 ;
2813
2814   arg1 = (intp *)jarg1;
2815   {
2816     try {
2817       delete_intp(arg1);
2818     } catch (std::out_of_range& e) {
2819       {
2820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2821       };
2822     } catch (std::exception& e) {
2823       {
2824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2825       };
2826     } catch (Dali::DaliException e) {
2827       {
2828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2829       };
2830     } catch (...) {
2831       {
2832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2833       };
2834     }
2835   }
2836
2837 }
2838
2839
2840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2841   intp *arg1 = (intp *) 0 ;
2842   int arg2 ;
2843
2844   arg1 = (intp *)jarg1;
2845   arg2 = (int)jarg2;
2846   {
2847     try {
2848       intp_assign(arg1,arg2);
2849     } catch (std::out_of_range& e) {
2850       {
2851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2852       };
2853     } catch (std::exception& e) {
2854       {
2855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2856       };
2857     } catch (Dali::DaliException e) {
2858       {
2859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2860       };
2861     } catch (...) {
2862       {
2863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2864       };
2865     }
2866   }
2867
2868 }
2869
2870
2871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2872   int jresult ;
2873   intp *arg1 = (intp *) 0 ;
2874   int result;
2875
2876   arg1 = (intp *)jarg1;
2877   {
2878     try {
2879       result = (int)intp_value(arg1);
2880     } catch (std::out_of_range& e) {
2881       {
2882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2883       };
2884     } catch (std::exception& e) {
2885       {
2886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2887       };
2888     } catch (Dali::DaliException e) {
2889       {
2890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2891       };
2892     } catch (...) {
2893       {
2894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2895       };
2896     }
2897   }
2898
2899   jresult = result;
2900   return jresult;
2901 }
2902
2903
2904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2905   void * jresult ;
2906   intp *arg1 = (intp *) 0 ;
2907   int *result = 0 ;
2908
2909   arg1 = (intp *)jarg1;
2910   {
2911     try {
2912       result = (int *)intp_cast(arg1);
2913     } catch (std::out_of_range& e) {
2914       {
2915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2916       };
2917     } catch (std::exception& e) {
2918       {
2919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2920       };
2921     } catch (Dali::DaliException e) {
2922       {
2923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2924       };
2925     } catch (...) {
2926       {
2927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2928       };
2929     }
2930   }
2931
2932   jresult = (void *)result;
2933   return jresult;
2934 }
2935
2936
2937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2938   void * jresult ;
2939   int *arg1 = (int *) 0 ;
2940   intp *result = 0 ;
2941
2942   arg1 = (int *)jarg1;
2943   {
2944     try {
2945       result = (intp *)intp_frompointer(arg1);
2946     } catch (std::out_of_range& e) {
2947       {
2948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2949       };
2950     } catch (std::exception& e) {
2951       {
2952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2953       };
2954     } catch (Dali::DaliException e) {
2955       {
2956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2957       };
2958     } catch (...) {
2959       {
2960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2961       };
2962     }
2963   }
2964
2965   jresult = (void *)result;
2966   return jresult;
2967 }
2968
2969
2970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2971   void * jresult ;
2972   doublep *result = 0 ;
2973
2974   {
2975     try {
2976       result = (doublep *)new_doublep();
2977     } catch (std::out_of_range& e) {
2978       {
2979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2980       };
2981     } catch (std::exception& e) {
2982       {
2983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2984       };
2985     } catch (Dali::DaliException e) {
2986       {
2987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2988       };
2989     } catch (...) {
2990       {
2991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2992       };
2993     }
2994   }
2995
2996   jresult = (void *)result;
2997   return jresult;
2998 }
2999
3000
3001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
3002   doublep *arg1 = (doublep *) 0 ;
3003
3004   arg1 = (doublep *)jarg1;
3005   {
3006     try {
3007       delete_doublep(arg1);
3008     } catch (std::out_of_range& e) {
3009       {
3010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3011       };
3012     } catch (std::exception& e) {
3013       {
3014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3015       };
3016     } catch (Dali::DaliException e) {
3017       {
3018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3019       };
3020     } catch (...) {
3021       {
3022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3023       };
3024     }
3025   }
3026
3027 }
3028
3029
3030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3031   doublep *arg1 = (doublep *) 0 ;
3032   double arg2 ;
3033
3034   arg1 = (doublep *)jarg1;
3035   arg2 = (double)jarg2;
3036   {
3037     try {
3038       doublep_assign(arg1,arg2);
3039     } catch (std::out_of_range& e) {
3040       {
3041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3042       };
3043     } catch (std::exception& e) {
3044       {
3045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3046       };
3047     } catch (Dali::DaliException e) {
3048       {
3049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3050       };
3051     } catch (...) {
3052       {
3053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3054       };
3055     }
3056   }
3057
3058 }
3059
3060
3061 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3062   double jresult ;
3063   doublep *arg1 = (doublep *) 0 ;
3064   double result;
3065
3066   arg1 = (doublep *)jarg1;
3067   {
3068     try {
3069       result = (double)doublep_value(arg1);
3070     } catch (std::out_of_range& e) {
3071       {
3072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3073       };
3074     } catch (std::exception& e) {
3075       {
3076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3077       };
3078     } catch (Dali::DaliException e) {
3079       {
3080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3081       };
3082     } catch (...) {
3083       {
3084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3085       };
3086     }
3087   }
3088
3089   jresult = result;
3090   return jresult;
3091 }
3092
3093
3094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3095   void * jresult ;
3096   doublep *arg1 = (doublep *) 0 ;
3097   double *result = 0 ;
3098
3099   arg1 = (doublep *)jarg1;
3100   {
3101     try {
3102       result = (double *)doublep_cast(arg1);
3103     } catch (std::out_of_range& e) {
3104       {
3105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3106       };
3107     } catch (std::exception& e) {
3108       {
3109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3110       };
3111     } catch (Dali::DaliException e) {
3112       {
3113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3114       };
3115     } catch (...) {
3116       {
3117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3118       };
3119     }
3120   }
3121
3122   jresult = (void *)result;
3123   return jresult;
3124 }
3125
3126
3127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3128   void * jresult ;
3129   double *arg1 = (double *) 0 ;
3130   doublep *result = 0 ;
3131
3132   arg1 = (double *)jarg1;
3133   {
3134     try {
3135       result = (doublep *)doublep_frompointer(arg1);
3136     } catch (std::out_of_range& e) {
3137       {
3138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3139       };
3140     } catch (std::exception& e) {
3141       {
3142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3143       };
3144     } catch (Dali::DaliException e) {
3145       {
3146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3147       };
3148     } catch (...) {
3149       {
3150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3151       };
3152     }
3153   }
3154
3155   jresult = (void *)result;
3156   return jresult;
3157 }
3158
3159
3160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3161   void * jresult ;
3162   uintp *result = 0 ;
3163
3164   {
3165     try {
3166       result = (uintp *)new_uintp();
3167     } catch (std::out_of_range& e) {
3168       {
3169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3170       };
3171     } catch (std::exception& e) {
3172       {
3173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3174       };
3175     } catch (Dali::DaliException e) {
3176       {
3177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3178       };
3179     } catch (...) {
3180       {
3181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3182       };
3183     }
3184   }
3185
3186   jresult = (void *)result;
3187   return jresult;
3188 }
3189
3190
3191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3192   uintp *arg1 = (uintp *) 0 ;
3193
3194   arg1 = (uintp *)jarg1;
3195   {
3196     try {
3197       delete_uintp(arg1);
3198     } catch (std::out_of_range& e) {
3199       {
3200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3201       };
3202     } catch (std::exception& e) {
3203       {
3204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3205       };
3206     } catch (Dali::DaliException e) {
3207       {
3208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3209       };
3210     } catch (...) {
3211       {
3212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3213       };
3214     }
3215   }
3216
3217 }
3218
3219
3220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3221   uintp *arg1 = (uintp *) 0 ;
3222   unsigned int arg2 ;
3223
3224   arg1 = (uintp *)jarg1;
3225   arg2 = (unsigned int)jarg2;
3226   {
3227     try {
3228       uintp_assign(arg1,arg2);
3229     } catch (std::out_of_range& e) {
3230       {
3231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3232       };
3233     } catch (std::exception& e) {
3234       {
3235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3236       };
3237     } catch (Dali::DaliException e) {
3238       {
3239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3240       };
3241     } catch (...) {
3242       {
3243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3244       };
3245     }
3246   }
3247
3248 }
3249
3250
3251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3252   unsigned int jresult ;
3253   uintp *arg1 = (uintp *) 0 ;
3254   unsigned int result;
3255
3256   arg1 = (uintp *)jarg1;
3257   {
3258     try {
3259       result = (unsigned int)uintp_value(arg1);
3260     } catch (std::out_of_range& e) {
3261       {
3262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3263       };
3264     } catch (std::exception& e) {
3265       {
3266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3267       };
3268     } catch (Dali::DaliException e) {
3269       {
3270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3271       };
3272     } catch (...) {
3273       {
3274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3275       };
3276     }
3277   }
3278
3279   jresult = result;
3280   return jresult;
3281 }
3282
3283
3284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3285   void * jresult ;
3286   uintp *arg1 = (uintp *) 0 ;
3287   unsigned int *result = 0 ;
3288
3289   arg1 = (uintp *)jarg1;
3290   {
3291     try {
3292       result = (unsigned int *)uintp_cast(arg1);
3293     } catch (std::out_of_range& e) {
3294       {
3295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3296       };
3297     } catch (std::exception& e) {
3298       {
3299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3300       };
3301     } catch (Dali::DaliException e) {
3302       {
3303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3304       };
3305     } catch (...) {
3306       {
3307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3308       };
3309     }
3310   }
3311
3312   jresult = (void *)result;
3313   return jresult;
3314 }
3315
3316
3317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3318   void * jresult ;
3319   unsigned int *arg1 = (unsigned int *) 0 ;
3320   uintp *result = 0 ;
3321
3322   arg1 = (unsigned int *)jarg1;
3323   {
3324     try {
3325       result = (uintp *)uintp_frompointer(arg1);
3326     } catch (std::out_of_range& e) {
3327       {
3328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3329       };
3330     } catch (std::exception& e) {
3331       {
3332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3333       };
3334     } catch (Dali::DaliException e) {
3335       {
3336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3337       };
3338     } catch (...) {
3339       {
3340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3341       };
3342     }
3343   }
3344
3345   jresult = (void *)result;
3346   return jresult;
3347 }
3348
3349
3350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3351   void * jresult ;
3352   ushortp *result = 0 ;
3353
3354   {
3355     try {
3356       result = (ushortp *)new_ushortp();
3357     } catch (std::out_of_range& e) {
3358       {
3359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3360       };
3361     } catch (std::exception& e) {
3362       {
3363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3364       };
3365     } catch (Dali::DaliException e) {
3366       {
3367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3368       };
3369     } catch (...) {
3370       {
3371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3372       };
3373     }
3374   }
3375
3376   jresult = (void *)result;
3377   return jresult;
3378 }
3379
3380
3381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3382   ushortp *arg1 = (ushortp *) 0 ;
3383
3384   arg1 = (ushortp *)jarg1;
3385   {
3386     try {
3387       delete_ushortp(arg1);
3388     } catch (std::out_of_range& e) {
3389       {
3390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3391       };
3392     } catch (std::exception& e) {
3393       {
3394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3395       };
3396     } catch (Dali::DaliException e) {
3397       {
3398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3399       };
3400     } catch (...) {
3401       {
3402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3403       };
3404     }
3405   }
3406
3407 }
3408
3409
3410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3411   ushortp *arg1 = (ushortp *) 0 ;
3412   unsigned short arg2 ;
3413
3414   arg1 = (ushortp *)jarg1;
3415   arg2 = (unsigned short)jarg2;
3416   {
3417     try {
3418       ushortp_assign(arg1,arg2);
3419     } catch (std::out_of_range& e) {
3420       {
3421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3422       };
3423     } catch (std::exception& e) {
3424       {
3425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3426       };
3427     } catch (Dali::DaliException e) {
3428       {
3429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3430       };
3431     } catch (...) {
3432       {
3433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3434       };
3435     }
3436   }
3437
3438 }
3439
3440
3441 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3442   unsigned short jresult ;
3443   ushortp *arg1 = (ushortp *) 0 ;
3444   unsigned short result;
3445
3446   arg1 = (ushortp *)jarg1;
3447   {
3448     try {
3449       result = (unsigned short)ushortp_value(arg1);
3450     } catch (std::out_of_range& e) {
3451       {
3452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3453       };
3454     } catch (std::exception& e) {
3455       {
3456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3457       };
3458     } catch (Dali::DaliException e) {
3459       {
3460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3461       };
3462     } catch (...) {
3463       {
3464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3465       };
3466     }
3467   }
3468
3469   jresult = result;
3470   return jresult;
3471 }
3472
3473
3474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3475   void * jresult ;
3476   ushortp *arg1 = (ushortp *) 0 ;
3477   unsigned short *result = 0 ;
3478
3479   arg1 = (ushortp *)jarg1;
3480   {
3481     try {
3482       result = (unsigned short *)ushortp_cast(arg1);
3483     } catch (std::out_of_range& e) {
3484       {
3485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3486       };
3487     } catch (std::exception& e) {
3488       {
3489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3490       };
3491     } catch (Dali::DaliException e) {
3492       {
3493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3494       };
3495     } catch (...) {
3496       {
3497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3498       };
3499     }
3500   }
3501
3502   jresult = (void *)result;
3503   return jresult;
3504 }
3505
3506
3507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3508   void * jresult ;
3509   unsigned short *arg1 = (unsigned short *) 0 ;
3510   ushortp *result = 0 ;
3511
3512   arg1 = (unsigned short *)jarg1;
3513   {
3514     try {
3515       result = (ushortp *)ushortp_frompointer(arg1);
3516     } catch (std::out_of_range& e) {
3517       {
3518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3519       };
3520     } catch (std::exception& e) {
3521       {
3522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3523       };
3524     } catch (Dali::DaliException e) {
3525       {
3526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3527       };
3528     } catch (...) {
3529       {
3530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3531       };
3532     }
3533   }
3534
3535   jresult = (void *)result;
3536   return jresult;
3537 }
3538
3539
3540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3541   unsigned int jresult ;
3542   int arg1 ;
3543   unsigned int result;
3544
3545   arg1 = (int)jarg1;
3546   {
3547     try {
3548       result = (unsigned int)int_to_uint(arg1);
3549     } catch (std::out_of_range& e) {
3550       {
3551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3552       };
3553     } catch (std::exception& e) {
3554       {
3555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3556       };
3557     } catch (Dali::DaliException e) {
3558       {
3559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3560       };
3561     } catch (...) {
3562       {
3563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3564       };
3565     }
3566   }
3567
3568   jresult = result;
3569   return jresult;
3570 }
3571
3572
3573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3574   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3575
3576   arg1 = (Dali::RefObject *)jarg1;
3577   {
3578     try {
3579       (arg1)->Reference();
3580     } catch (std::out_of_range& e) {
3581       {
3582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3583       };
3584     } catch (std::exception& e) {
3585       {
3586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3587       };
3588     } catch (Dali::DaliException e) {
3589       {
3590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3591       };
3592     } catch (...) {
3593       {
3594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3595       };
3596     }
3597   }
3598
3599 }
3600
3601
3602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3603   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3604
3605   arg1 = (Dali::RefObject *)jarg1;
3606   {
3607     try {
3608       (arg1)->Unreference();
3609     } catch (std::out_of_range& e) {
3610       {
3611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3612       };
3613     } catch (std::exception& e) {
3614       {
3615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3616       };
3617     } catch (Dali::DaliException e) {
3618       {
3619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3620       };
3621     } catch (...) {
3622       {
3623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3624       };
3625     }
3626   }
3627
3628 }
3629
3630
3631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3632   int jresult ;
3633   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3634   int result;
3635
3636   arg1 = (Dali::RefObject *)jarg1;
3637   {
3638     try {
3639       result = (int)(arg1)->ReferenceCount();
3640     } catch (std::out_of_range& e) {
3641       {
3642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3643       };
3644     } catch (std::exception& e) {
3645       {
3646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3647       };
3648     } catch (Dali::DaliException e) {
3649       {
3650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3651       };
3652     } catch (...) {
3653       {
3654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3655       };
3656     }
3657   }
3658
3659   jresult = result;
3660   return jresult;
3661 }
3662
3663
3664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3665   void * jresult ;
3666   Dali::Any *result = 0 ;
3667
3668   {
3669     try {
3670       result = (Dali::Any *)new Dali::Any();
3671     } catch (std::out_of_range& e) {
3672       {
3673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3674       };
3675     } catch (std::exception& e) {
3676       {
3677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3678       };
3679     } catch (Dali::DaliException e) {
3680       {
3681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3682       };
3683     } catch (...) {
3684       {
3685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3686       };
3687     }
3688   }
3689
3690   jresult = (void *)result;
3691   return jresult;
3692 }
3693
3694
3695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3696   Dali::Any *arg1 = (Dali::Any *) 0 ;
3697
3698   arg1 = (Dali::Any *)jarg1;
3699   {
3700     try {
3701       delete arg1;
3702     } catch (std::out_of_range& e) {
3703       {
3704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3705       };
3706     } catch (std::exception& e) {
3707       {
3708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3709       };
3710     } catch (Dali::DaliException e) {
3711       {
3712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3713       };
3714     } catch (...) {
3715       {
3716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3717       };
3718     }
3719   }
3720
3721 }
3722
3723
3724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3725   char *arg1 = (char *) 0 ;
3726
3727   arg1 = (char *)jarg1;
3728   {
3729     try {
3730       Dali::Any::AssertAlways((char const *)arg1);
3731     } catch (std::out_of_range& e) {
3732       {
3733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3734       };
3735     } catch (std::exception& e) {
3736       {
3737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3738       };
3739     } catch (Dali::DaliException e) {
3740       {
3741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3742       };
3743     } catch (...) {
3744       {
3745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3746       };
3747     }
3748   }
3749
3750 }
3751
3752
3753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3754   void * jresult ;
3755   Dali::Any *arg1 = 0 ;
3756   Dali::Any *result = 0 ;
3757
3758   arg1 = (Dali::Any *)jarg1;
3759   if (!arg1) {
3760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3761     return 0;
3762   }
3763   {
3764     try {
3765       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3766     } catch (std::out_of_range& e) {
3767       {
3768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3769       };
3770     } catch (std::exception& e) {
3771       {
3772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3773       };
3774     } catch (Dali::DaliException e) {
3775       {
3776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3777       };
3778     } catch (...) {
3779       {
3780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3781       };
3782     }
3783   }
3784
3785   jresult = (void *)result;
3786   return jresult;
3787 }
3788
3789
3790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3791   void * jresult ;
3792   Dali::Any *arg1 = (Dali::Any *) 0 ;
3793   Dali::Any *arg2 = 0 ;
3794   Dali::Any *result = 0 ;
3795
3796   arg1 = (Dali::Any *)jarg1;
3797   arg2 = (Dali::Any *)jarg2;
3798   if (!arg2) {
3799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3800     return 0;
3801   }
3802   {
3803     try {
3804       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3805     } catch (std::out_of_range& e) {
3806       {
3807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3808       };
3809     } catch (std::exception& e) {
3810       {
3811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3812       };
3813     } catch (Dali::DaliException e) {
3814       {
3815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3816       };
3817     } catch (...) {
3818       {
3819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3820       };
3821     }
3822   }
3823
3824   jresult = (void *)result;
3825   return jresult;
3826 }
3827
3828
3829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3830   void * jresult ;
3831   Dali::Any *arg1 = (Dali::Any *) 0 ;
3832   std::type_info *result = 0 ;
3833
3834   arg1 = (Dali::Any *)jarg1;
3835   {
3836     try {
3837       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3838     } catch (std::out_of_range& e) {
3839       {
3840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3841       };
3842     } catch (std::exception& e) {
3843       {
3844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3845       };
3846     } catch (Dali::DaliException e) {
3847       {
3848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3849       };
3850     } catch (...) {
3851       {
3852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3853       };
3854     }
3855   }
3856
3857   jresult = (void *)result;
3858   return jresult;
3859 }
3860
3861
3862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3863   unsigned int jresult ;
3864   Dali::Any *arg1 = (Dali::Any *) 0 ;
3865   bool result;
3866
3867   arg1 = (Dali::Any *)jarg1;
3868   {
3869     try {
3870       result = (bool)((Dali::Any const *)arg1)->Empty();
3871     } catch (std::out_of_range& e) {
3872       {
3873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3874       };
3875     } catch (std::exception& e) {
3876       {
3877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3878       };
3879     } catch (Dali::DaliException e) {
3880       {
3881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3882       };
3883     } catch (...) {
3884       {
3885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3886       };
3887     }
3888   }
3889
3890   jresult = result;
3891   return jresult;
3892 }
3893
3894
3895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3896   void * jresult ;
3897   std::type_info *arg1 = 0 ;
3898   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3899   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3900   Dali::Any::AnyContainerBase *result = 0 ;
3901
3902   arg1 = (std::type_info *)jarg1;
3903   if (!arg1) {
3904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3905     return 0;
3906   }
3907   arg2 = (Dali::Any::CloneFunc)jarg2;
3908   arg3 = (Dali::Any::DeleteFunc)jarg3;
3909   {
3910     try {
3911       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3912     } catch (std::out_of_range& e) {
3913       {
3914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3915       };
3916     } catch (std::exception& e) {
3917       {
3918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3919       };
3920     } catch (Dali::DaliException e) {
3921       {
3922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3923       };
3924     } catch (...) {
3925       {
3926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3927       };
3928     }
3929   }
3930
3931   jresult = (void *)result;
3932   return jresult;
3933 }
3934
3935
3936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3937   void * jresult ;
3938   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3939   std::type_info *result = 0 ;
3940
3941   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3942   {
3943     try {
3944       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3945     } catch (std::out_of_range& e) {
3946       {
3947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3948       };
3949     } catch (std::exception& e) {
3950       {
3951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3952       };
3953     } catch (Dali::DaliException e) {
3954       {
3955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3956       };
3957     } catch (...) {
3958       {
3959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3960       };
3961     }
3962   }
3963
3964   jresult = (void *)result;
3965   return jresult;
3966 }
3967
3968
3969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3970   void * jresult ;
3971   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3972   ::std::type_info *result = 0 ;
3973
3974   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3975   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3976   jresult = (void *)result;
3977   return jresult;
3978 }
3979
3980
3981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3982   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3983   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3984
3985   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3986   arg2 = (Dali::Any::CloneFunc)jarg2;
3987   if (arg1) (arg1)->mCloneFunc = arg2;
3988 }
3989
3990
3991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3992   void * jresult ;
3993   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3994   Dali::Any::CloneFunc result;
3995
3996   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3997   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3998   jresult = (void *)result;
3999   return jresult;
4000 }
4001
4002
4003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4004   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4005   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4006
4007   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4008   arg2 = (Dali::Any::DeleteFunc)jarg2;
4009   if (arg1) (arg1)->mDeleteFunc = arg2;
4010 }
4011
4012
4013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4014   void * jresult ;
4015   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4016   Dali::Any::DeleteFunc result;
4017
4018   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4019   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4020   jresult = (void *)result;
4021   return jresult;
4022 }
4023
4024
4025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4026   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4027
4028   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4029   {
4030     try {
4031       delete arg1;
4032     } catch (std::out_of_range& e) {
4033       {
4034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4035       };
4036     } catch (std::exception& e) {
4037       {
4038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4039       };
4040     } catch (Dali::DaliException e) {
4041       {
4042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4043       };
4044     } catch (...) {
4045       {
4046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4047       };
4048     }
4049   }
4050
4051 }
4052
4053
4054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4055   Dali::Any *arg1 = (Dali::Any *) 0 ;
4056   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4057
4058   arg1 = (Dali::Any *)jarg1;
4059   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4060   if (arg1) (arg1)->mContainer = arg2;
4061 }
4062
4063
4064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4065   void * jresult ;
4066   Dali::Any *arg1 = (Dali::Any *) 0 ;
4067   Dali::Any::AnyContainerBase *result = 0 ;
4068
4069   arg1 = (Dali::Any *)jarg1;
4070   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4071   jresult = (void *)result;
4072   return jresult;
4073 }
4074
4075
4076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4077   char *arg1 = (char *) 0 ;
4078   char *arg2 = (char *) 0 ;
4079
4080   arg1 = (char *)jarg1;
4081   arg2 = (char *)jarg2;
4082   {
4083     try {
4084       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4085     } catch (std::out_of_range& e) {
4086       {
4087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4088       };
4089     } catch (std::exception& e) {
4090       {
4091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4092       };
4093     } catch (Dali::DaliException e) {
4094       {
4095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4096       };
4097     } catch (...) {
4098       {
4099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4100       };
4101     }
4102   }
4103
4104 }
4105
4106
4107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4108   void * jresult ;
4109   char *arg1 = (char *) 0 ;
4110   char *arg2 = (char *) 0 ;
4111   Dali::DaliException *result = 0 ;
4112
4113   arg1 = (char *)jarg1;
4114   arg2 = (char *)jarg2;
4115   {
4116     try {
4117       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4118     } catch (std::out_of_range& e) {
4119       {
4120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4121       };
4122     } catch (std::exception& e) {
4123       {
4124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4125       };
4126     } catch (Dali::DaliException e) {
4127       {
4128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4129       };
4130     } catch (...) {
4131       {
4132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4133       };
4134     }
4135   }
4136
4137   jresult = (void *)result;
4138   return jresult;
4139 }
4140
4141
4142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4143   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4144   std::string arg2 = std::string(jarg2);
4145
4146   arg1 = (Dali::DaliException *)jarg1;
4147   {
4148     if (!arg2.empty()) {
4149       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4150     } else {
4151       arg1->location = 0;
4152     }
4153   }
4154 }
4155
4156 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4157   char * jresult ;
4158   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4159   char *result = 0 ;
4160
4161   arg1 = (Dali::DaliException *)jarg1;
4162   result = (char *) ((arg1)->location);
4163   jresult = SWIG_csharp_string_callback((const char *)result);
4164   return jresult;
4165 }
4166
4167
4168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4169   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4170   std::string arg2 = std::string(jarg2);
4171
4172   arg1 = (Dali::DaliException *)jarg1;
4173   {
4174     if (!arg2.empty()) {
4175       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4176     } else {
4177       arg1->condition = 0;
4178     }
4179   }
4180 }
4181
4182
4183 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4184   char * jresult ;
4185   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4186   char *result = 0 ;
4187
4188   arg1 = (Dali::DaliException *)jarg1;
4189   result = (char *) ((arg1)->condition);
4190   jresult = SWIG_csharp_string_callback((const char *)result);
4191   return jresult;
4192 }
4193
4194
4195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4196   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4197
4198   arg1 = (Dali::DaliException *)jarg1;
4199   {
4200     try {
4201       delete arg1;
4202     } catch (std::out_of_range& e) {
4203       {
4204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4205       };
4206     } catch (std::exception& e) {
4207       {
4208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4209       };
4210     } catch (Dali::DaliException e) {
4211       {
4212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4213       };
4214     } catch (...) {
4215       {
4216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4217       };
4218     }
4219   }
4220
4221 }
4222
4223
4224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4225   void * jresult ;
4226   Dali::Vector2 *result = 0 ;
4227
4228   {
4229     try {
4230       result = (Dali::Vector2 *)new Dali::Vector2();
4231     } catch (std::out_of_range& e) {
4232       {
4233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4234       };
4235     } catch (std::exception& e) {
4236       {
4237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4238       };
4239     } catch (Dali::DaliException e) {
4240       {
4241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4242       };
4243     } catch (...) {
4244       {
4245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4246       };
4247     }
4248   }
4249
4250   jresult = (void *)result;
4251   return jresult;
4252 }
4253
4254
4255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4256   void * jresult ;
4257   float arg1 ;
4258   float arg2 ;
4259   Dali::Vector2 *result = 0 ;
4260
4261   arg1 = (float)jarg1;
4262   arg2 = (float)jarg2;
4263   {
4264     try {
4265       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4266     } catch (std::out_of_range& e) {
4267       {
4268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4269       };
4270     } catch (std::exception& e) {
4271       {
4272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4273       };
4274     } catch (Dali::DaliException e) {
4275       {
4276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4277       };
4278     } catch (...) {
4279       {
4280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4281       };
4282     }
4283   }
4284
4285   jresult = (void *)result;
4286   return jresult;
4287 }
4288
4289
4290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4291   void * jresult ;
4292   float *arg1 = (float *) 0 ;
4293   Dali::Vector2 *result = 0 ;
4294
4295   arg1 = jarg1;
4296   {
4297     try {
4298       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4299     } catch (std::out_of_range& e) {
4300       {
4301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4302       };
4303     } catch (std::exception& e) {
4304       {
4305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4306       };
4307     } catch (Dali::DaliException e) {
4308       {
4309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4310       };
4311     } catch (...) {
4312       {
4313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4314       };
4315     }
4316   }
4317
4318   jresult = (void *)result;
4319
4320
4321   return jresult;
4322 }
4323
4324
4325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4326   void * jresult ;
4327   Dali::Vector3 *arg1 = 0 ;
4328   Dali::Vector2 *result = 0 ;
4329
4330   arg1 = (Dali::Vector3 *)jarg1;
4331   if (!arg1) {
4332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4333     return 0;
4334   }
4335   {
4336     try {
4337       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4338     } catch (std::out_of_range& e) {
4339       {
4340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4341       };
4342     } catch (std::exception& e) {
4343       {
4344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4345       };
4346     } catch (Dali::DaliException e) {
4347       {
4348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4349       };
4350     } catch (...) {
4351       {
4352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4353       };
4354     }
4355   }
4356
4357   jresult = (void *)result;
4358   return jresult;
4359 }
4360
4361
4362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4363   void * jresult ;
4364   Dali::Vector4 *arg1 = 0 ;
4365   Dali::Vector2 *result = 0 ;
4366
4367   arg1 = (Dali::Vector4 *)jarg1;
4368   if (!arg1) {
4369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4370     return 0;
4371   }
4372   {
4373     try {
4374       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4375     } catch (std::out_of_range& e) {
4376       {
4377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4378       };
4379     } catch (std::exception& e) {
4380       {
4381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4382       };
4383     } catch (Dali::DaliException e) {
4384       {
4385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4386       };
4387     } catch (...) {
4388       {
4389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4390       };
4391     }
4392   }
4393
4394   jresult = (void *)result;
4395   return jresult;
4396 }
4397
4398
4399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4400   void * jresult ;
4401   Dali::Vector2 *result = 0 ;
4402
4403   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4404   jresult = (void *)result;
4405   return jresult;
4406 }
4407
4408
4409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4410   void * jresult ;
4411   Dali::Vector2 *result = 0 ;
4412
4413   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4414   jresult = (void *)result;
4415   return jresult;
4416 }
4417
4418
4419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4420   void * jresult ;
4421   Dali::Vector2 *result = 0 ;
4422
4423   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4424   jresult = (void *)result;
4425   return jresult;
4426 }
4427
4428
4429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4430   void * jresult ;
4431   Dali::Vector2 *result = 0 ;
4432
4433   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4434   jresult = (void *)result;
4435   return jresult;
4436 }
4437
4438
4439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4440   void * jresult ;
4441   Dali::Vector2 *result = 0 ;
4442
4443   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4444   jresult = (void *)result;
4445   return jresult;
4446 }
4447
4448
4449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4450   void * jresult ;
4451   Dali::Vector2 *result = 0 ;
4452
4453   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4454   jresult = (void *)result;
4455   return jresult;
4456 }
4457
4458
4459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4460   void * jresult ;
4461   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4462   float *arg2 = (float *) 0 ;
4463   Dali::Vector2 *result = 0 ;
4464
4465   arg1 = (Dali::Vector2 *)jarg1;
4466   arg2 = jarg2;
4467   {
4468     try {
4469       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4470     } catch (std::out_of_range& e) {
4471       {
4472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4473       };
4474     } catch (std::exception& e) {
4475       {
4476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4477       };
4478     } catch (Dali::DaliException e) {
4479       {
4480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4481       };
4482     } catch (...) {
4483       {
4484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4485       };
4486     }
4487   }
4488
4489   jresult = (void *)result;
4490
4491
4492   return jresult;
4493 }
4494
4495
4496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4497   void * jresult ;
4498   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4499   Dali::Vector3 *arg2 = 0 ;
4500   Dali::Vector2 *result = 0 ;
4501
4502   arg1 = (Dali::Vector2 *)jarg1;
4503   arg2 = (Dali::Vector3 *)jarg2;
4504   if (!arg2) {
4505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4506     return 0;
4507   }
4508   {
4509     try {
4510       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4511     } catch (std::out_of_range& e) {
4512       {
4513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4514       };
4515     } catch (std::exception& e) {
4516       {
4517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4518       };
4519     } catch (Dali::DaliException e) {
4520       {
4521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4522       };
4523     } catch (...) {
4524       {
4525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4526       };
4527     }
4528   }
4529
4530   jresult = (void *)result;
4531   return jresult;
4532 }
4533
4534
4535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4536   void * jresult ;
4537   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4538   Dali::Vector4 *arg2 = 0 ;
4539   Dali::Vector2 *result = 0 ;
4540
4541   arg1 = (Dali::Vector2 *)jarg1;
4542   arg2 = (Dali::Vector4 *)jarg2;
4543   if (!arg2) {
4544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4545     return 0;
4546   }
4547   {
4548     try {
4549       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4550     } catch (std::out_of_range& e) {
4551       {
4552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4553       };
4554     } catch (std::exception& e) {
4555       {
4556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4557       };
4558     } catch (Dali::DaliException e) {
4559       {
4560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4561       };
4562     } catch (...) {
4563       {
4564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4565       };
4566     }
4567   }
4568
4569   jresult = (void *)result;
4570   return jresult;
4571 }
4572
4573
4574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4575   void * jresult ;
4576   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4577   Dali::Vector2 *arg2 = 0 ;
4578   Dali::Vector2 result;
4579
4580   arg1 = (Dali::Vector2 *)jarg1;
4581   arg2 = (Dali::Vector2 *)jarg2;
4582   if (!arg2) {
4583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4584     return 0;
4585   }
4586   {
4587     try {
4588       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4589     } catch (std::out_of_range& e) {
4590       {
4591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4592       };
4593     } catch (std::exception& e) {
4594       {
4595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4596       };
4597     } catch (Dali::DaliException e) {
4598       {
4599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4600       };
4601     } catch (...) {
4602       {
4603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4604       };
4605     }
4606   }
4607
4608   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4609   return jresult;
4610 }
4611
4612
4613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4614   void * jresult ;
4615   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4616   Dali::Vector2 *arg2 = 0 ;
4617   Dali::Vector2 *result = 0 ;
4618
4619   arg1 = (Dali::Vector2 *)jarg1;
4620   arg2 = (Dali::Vector2 *)jarg2;
4621   if (!arg2) {
4622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4623     return 0;
4624   }
4625   {
4626     try {
4627       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4628     } catch (std::out_of_range& e) {
4629       {
4630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4631       };
4632     } catch (std::exception& e) {
4633       {
4634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4635       };
4636     } catch (Dali::DaliException e) {
4637       {
4638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4639       };
4640     } catch (...) {
4641       {
4642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4643       };
4644     }
4645   }
4646
4647   jresult = (void *)result;
4648   return jresult;
4649 }
4650
4651
4652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4653   void * jresult ;
4654   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4655   Dali::Vector2 *arg2 = 0 ;
4656   Dali::Vector2 result;
4657
4658   arg1 = (Dali::Vector2 *)jarg1;
4659   arg2 = (Dali::Vector2 *)jarg2;
4660   if (!arg2) {
4661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4662     return 0;
4663   }
4664   {
4665     try {
4666       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4667     } catch (std::out_of_range& e) {
4668       {
4669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4670       };
4671     } catch (std::exception& e) {
4672       {
4673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4674       };
4675     } catch (Dali::DaliException e) {
4676       {
4677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4678       };
4679     } catch (...) {
4680       {
4681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4682       };
4683     }
4684   }
4685
4686   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4687   return jresult;
4688 }
4689
4690
4691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4692   void * jresult ;
4693   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4694   Dali::Vector2 *arg2 = 0 ;
4695   Dali::Vector2 *result = 0 ;
4696
4697   arg1 = (Dali::Vector2 *)jarg1;
4698   arg2 = (Dali::Vector2 *)jarg2;
4699   if (!arg2) {
4700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4701     return 0;
4702   }
4703   {
4704     try {
4705       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4706     } catch (std::out_of_range& e) {
4707       {
4708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4709       };
4710     } catch (std::exception& e) {
4711       {
4712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4713       };
4714     } catch (Dali::DaliException e) {
4715       {
4716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4717       };
4718     } catch (...) {
4719       {
4720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4721       };
4722     }
4723   }
4724
4725   jresult = (void *)result;
4726   return jresult;
4727 }
4728
4729
4730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4731   void * jresult ;
4732   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4733   Dali::Vector2 *arg2 = 0 ;
4734   Dali::Vector2 result;
4735
4736   arg1 = (Dali::Vector2 *)jarg1;
4737   arg2 = (Dali::Vector2 *)jarg2;
4738   if (!arg2) {
4739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4740     return 0;
4741   }
4742   {
4743     try {
4744       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4745     } catch (std::out_of_range& e) {
4746       {
4747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4748       };
4749     } catch (std::exception& e) {
4750       {
4751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4752       };
4753     } catch (Dali::DaliException e) {
4754       {
4755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4756       };
4757     } catch (...) {
4758       {
4759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4760       };
4761     }
4762   }
4763
4764   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4765   return jresult;
4766 }
4767
4768
4769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4770   void * jresult ;
4771   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4772   float arg2 ;
4773   Dali::Vector2 result;
4774
4775   arg1 = (Dali::Vector2 *)jarg1;
4776   arg2 = (float)jarg2;
4777   {
4778     try {
4779       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4780     } catch (std::out_of_range& e) {
4781       {
4782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4783       };
4784     } catch (std::exception& e) {
4785       {
4786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4787       };
4788     } catch (Dali::DaliException e) {
4789       {
4790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4791       };
4792     } catch (...) {
4793       {
4794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4795       };
4796     }
4797   }
4798
4799   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4800   return jresult;
4801 }
4802
4803
4804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4805   void * jresult ;
4806   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4807   Dali::Vector2 *arg2 = 0 ;
4808   Dali::Vector2 *result = 0 ;
4809
4810   arg1 = (Dali::Vector2 *)jarg1;
4811   arg2 = (Dali::Vector2 *)jarg2;
4812   if (!arg2) {
4813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4814     return 0;
4815   }
4816   {
4817     try {
4818       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4819     } catch (std::out_of_range& e) {
4820       {
4821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4822       };
4823     } catch (std::exception& e) {
4824       {
4825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4826       };
4827     } catch (Dali::DaliException e) {
4828       {
4829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4830       };
4831     } catch (...) {
4832       {
4833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4834       };
4835     }
4836   }
4837
4838   jresult = (void *)result;
4839   return jresult;
4840 }
4841
4842
4843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4844   void * jresult ;
4845   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4846   float arg2 ;
4847   Dali::Vector2 *result = 0 ;
4848
4849   arg1 = (Dali::Vector2 *)jarg1;
4850   arg2 = (float)jarg2;
4851   {
4852     try {
4853       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4854     } catch (std::out_of_range& e) {
4855       {
4856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4857       };
4858     } catch (std::exception& e) {
4859       {
4860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4861       };
4862     } catch (Dali::DaliException e) {
4863       {
4864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4865       };
4866     } catch (...) {
4867       {
4868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4869       };
4870     }
4871   }
4872
4873   jresult = (void *)result;
4874   return jresult;
4875 }
4876
4877
4878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4879   void * jresult ;
4880   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4881   Dali::Vector2 *arg2 = 0 ;
4882   Dali::Vector2 result;
4883
4884   arg1 = (Dali::Vector2 *)jarg1;
4885   arg2 = (Dali::Vector2 *)jarg2;
4886   if (!arg2) {
4887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4888     return 0;
4889   }
4890   {
4891     try {
4892       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4893     } catch (std::out_of_range& e) {
4894       {
4895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4896       };
4897     } catch (std::exception& e) {
4898       {
4899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4900       };
4901     } catch (Dali::DaliException e) {
4902       {
4903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4904       };
4905     } catch (...) {
4906       {
4907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4908       };
4909     }
4910   }
4911
4912   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4913   return jresult;
4914 }
4915
4916
4917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4918   void * jresult ;
4919   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4920   float arg2 ;
4921   Dali::Vector2 result;
4922
4923   arg1 = (Dali::Vector2 *)jarg1;
4924   arg2 = (float)jarg2;
4925   {
4926     try {
4927       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4928     } catch (std::out_of_range& e) {
4929       {
4930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4931       };
4932     } catch (std::exception& e) {
4933       {
4934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4935       };
4936     } catch (Dali::DaliException e) {
4937       {
4938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4939       };
4940     } catch (...) {
4941       {
4942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4943       };
4944     }
4945   }
4946
4947   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4948   return jresult;
4949 }
4950
4951
4952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4953   void * jresult ;
4954   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4955   Dali::Vector2 *arg2 = 0 ;
4956   Dali::Vector2 *result = 0 ;
4957
4958   arg1 = (Dali::Vector2 *)jarg1;
4959   arg2 = (Dali::Vector2 *)jarg2;
4960   if (!arg2) {
4961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4962     return 0;
4963   }
4964   {
4965     try {
4966       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4967     } catch (std::out_of_range& e) {
4968       {
4969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4970       };
4971     } catch (std::exception& e) {
4972       {
4973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4974       };
4975     } catch (Dali::DaliException e) {
4976       {
4977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4978       };
4979     } catch (...) {
4980       {
4981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4982       };
4983     }
4984   }
4985
4986   jresult = (void *)result;
4987   return jresult;
4988 }
4989
4990
4991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4992   void * jresult ;
4993   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4994   float arg2 ;
4995   Dali::Vector2 *result = 0 ;
4996
4997   arg1 = (Dali::Vector2 *)jarg1;
4998   arg2 = (float)jarg2;
4999   {
5000     try {
5001       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
5002     } catch (std::out_of_range& e) {
5003       {
5004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5005       };
5006     } catch (std::exception& e) {
5007       {
5008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5009       };
5010     } catch (Dali::DaliException e) {
5011       {
5012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5013       };
5014     } catch (...) {
5015       {
5016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5017       };
5018     }
5019   }
5020
5021   jresult = (void *)result;
5022   return jresult;
5023 }
5024
5025
5026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5027   void * jresult ;
5028   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5029   Dali::Vector2 result;
5030
5031   arg1 = (Dali::Vector2 *)jarg1;
5032   {
5033     try {
5034       result = ((Dali::Vector2 const *)arg1)->operator -();
5035     } catch (std::out_of_range& e) {
5036       {
5037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5038       };
5039     } catch (std::exception& e) {
5040       {
5041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5042       };
5043     } catch (Dali::DaliException e) {
5044       {
5045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5046       };
5047     } catch (...) {
5048       {
5049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5050       };
5051     }
5052   }
5053
5054   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5055   return jresult;
5056 }
5057
5058
5059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5060   unsigned int jresult ;
5061   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5062   Dali::Vector2 *arg2 = 0 ;
5063   bool result;
5064
5065   arg1 = (Dali::Vector2 *)jarg1;
5066   arg2 = (Dali::Vector2 *)jarg2;
5067   if (!arg2) {
5068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5069     return 0;
5070   }
5071   {
5072     try {
5073       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5074     } catch (std::out_of_range& e) {
5075       {
5076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5077       };
5078     } catch (std::exception& e) {
5079       {
5080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5081       };
5082     } catch (Dali::DaliException e) {
5083       {
5084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5085       };
5086     } catch (...) {
5087       {
5088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5089       };
5090     }
5091   }
5092
5093   jresult = result;
5094   return jresult;
5095 }
5096
5097
5098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5099   unsigned int jresult ;
5100   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5101   Dali::Vector2 *arg2 = 0 ;
5102   bool result;
5103
5104   arg1 = (Dali::Vector2 *)jarg1;
5105   arg2 = (Dali::Vector2 *)jarg2;
5106   if (!arg2) {
5107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5108     return 0;
5109   }
5110   {
5111     try {
5112       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5113     } catch (std::out_of_range& e) {
5114       {
5115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5116       };
5117     } catch (std::exception& e) {
5118       {
5119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5120       };
5121     } catch (Dali::DaliException e) {
5122       {
5123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5124       };
5125     } catch (...) {
5126       {
5127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5128       };
5129     }
5130   }
5131
5132   jresult = result;
5133   return jresult;
5134 }
5135
5136
5137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5138   float jresult ;
5139   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5140   unsigned int arg2 ;
5141   float *result = 0 ;
5142
5143   arg1 = (Dali::Vector2 *)jarg1;
5144   arg2 = (unsigned int)jarg2;
5145   {
5146     try {
5147       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5148     } catch (std::out_of_range& e) {
5149       {
5150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5151       };
5152     } catch (std::exception& e) {
5153       {
5154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5155       };
5156     } catch (Dali::DaliException e) {
5157       {
5158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5159       };
5160     } catch (...) {
5161       {
5162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5163       };
5164     }
5165   }
5166
5167   jresult = *result;
5168   return jresult;
5169 }
5170
5171
5172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5173   float jresult ;
5174   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5175   float result;
5176
5177   arg1 = (Dali::Vector2 *)jarg1;
5178   {
5179     try {
5180       result = (float)((Dali::Vector2 const *)arg1)->Length();
5181     } catch (std::out_of_range& e) {
5182       {
5183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5184       };
5185     } catch (std::exception& e) {
5186       {
5187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5188       };
5189     } catch (Dali::DaliException e) {
5190       {
5191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5192       };
5193     } catch (...) {
5194       {
5195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5196       };
5197     }
5198   }
5199
5200   jresult = result;
5201   return jresult;
5202 }
5203
5204
5205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5206   float jresult ;
5207   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5208   float result;
5209
5210   arg1 = (Dali::Vector2 *)jarg1;
5211   {
5212     try {
5213       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5214     } catch (std::out_of_range& e) {
5215       {
5216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5217       };
5218     } catch (std::exception& e) {
5219       {
5220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5221       };
5222     } catch (Dali::DaliException e) {
5223       {
5224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5225       };
5226     } catch (...) {
5227       {
5228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5229       };
5230     }
5231   }
5232
5233   jresult = result;
5234   return jresult;
5235 }
5236
5237
5238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5239   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5240
5241   arg1 = (Dali::Vector2 *)jarg1;
5242   {
5243     try {
5244       (arg1)->Normalize();
5245     } catch (std::out_of_range& e) {
5246       {
5247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5248       };
5249     } catch (std::exception& e) {
5250       {
5251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5252       };
5253     } catch (Dali::DaliException e) {
5254       {
5255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5256       };
5257     } catch (...) {
5258       {
5259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5260       };
5261     }
5262   }
5263
5264 }
5265
5266
5267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5268   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5269   Dali::Vector2 *arg2 = 0 ;
5270   Dali::Vector2 *arg3 = 0 ;
5271
5272   arg1 = (Dali::Vector2 *)jarg1;
5273   arg2 = (Dali::Vector2 *)jarg2;
5274   if (!arg2) {
5275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5276     return ;
5277   }
5278   arg3 = (Dali::Vector2 *)jarg3;
5279   if (!arg3) {
5280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5281     return ;
5282   }
5283   {
5284     try {
5285       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5286     } catch (std::out_of_range& e) {
5287       {
5288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5289       };
5290     } catch (std::exception& e) {
5291       {
5292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5293       };
5294     } catch (Dali::DaliException e) {
5295       {
5296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5297       };
5298     } catch (...) {
5299       {
5300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5301       };
5302     }
5303   }
5304
5305 }
5306
5307
5308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5309   void * jresult ;
5310   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5311   float *result = 0 ;
5312
5313   arg1 = (Dali::Vector2 *)jarg1;
5314   {
5315     try {
5316       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5317     } catch (std::out_of_range& e) {
5318       {
5319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5320       };
5321     } catch (std::exception& e) {
5322       {
5323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5324       };
5325     } catch (Dali::DaliException e) {
5326       {
5327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5328       };
5329     } catch (...) {
5330       {
5331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5332       };
5333     }
5334   }
5335
5336   jresult = (void *)result;
5337   return jresult;
5338 }
5339
5340
5341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5342   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5343   float arg2 ;
5344
5345   arg1 = (Dali::Vector2 *)jarg1;
5346   arg2 = (float)jarg2;
5347   if (arg1) (arg1)->x = arg2;
5348 }
5349
5350
5351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5352   float jresult ;
5353   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5354   float result;
5355
5356   arg1 = (Dali::Vector2 *)jarg1;
5357   result = (float) ((arg1)->x);
5358   jresult = result;
5359   return jresult;
5360 }
5361
5362
5363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5364   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5365   float arg2 ;
5366
5367   arg1 = (Dali::Vector2 *)jarg1;
5368   arg2 = (float)jarg2;
5369   if (arg1) (arg1)->width = arg2;
5370 }
5371
5372
5373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5374   float jresult ;
5375   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5376   float result;
5377
5378   arg1 = (Dali::Vector2 *)jarg1;
5379   result = (float) ((arg1)->width);
5380   jresult = result;
5381   return jresult;
5382 }
5383
5384
5385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5386   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5387   float arg2 ;
5388
5389   arg1 = (Dali::Vector2 *)jarg1;
5390   arg2 = (float)jarg2;
5391   if (arg1) (arg1)->y = arg2;
5392 }
5393
5394
5395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5396   float jresult ;
5397   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5398   float result;
5399
5400   arg1 = (Dali::Vector2 *)jarg1;
5401   result = (float) ((arg1)->y);
5402   jresult = result;
5403   return jresult;
5404 }
5405
5406
5407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5408   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5409   float arg2 ;
5410
5411   arg1 = (Dali::Vector2 *)jarg1;
5412   arg2 = (float)jarg2;
5413   if (arg1) (arg1)->height = arg2;
5414 }
5415
5416
5417 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5418   float jresult ;
5419   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5420   float result;
5421
5422   arg1 = (Dali::Vector2 *)jarg1;
5423   result = (float) ((arg1)->height);
5424   jresult = result;
5425   return jresult;
5426 }
5427
5428
5429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5430   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5431
5432   arg1 = (Dali::Vector2 *)jarg1;
5433   {
5434     try {
5435       delete arg1;
5436     } catch (std::out_of_range& e) {
5437       {
5438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5439       };
5440     } catch (std::exception& e) {
5441       {
5442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5443       };
5444     } catch (Dali::DaliException e) {
5445       {
5446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5447       };
5448     } catch (...) {
5449       {
5450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5451       };
5452     }
5453   }
5454
5455 }
5456
5457
5458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5459   void * jresult ;
5460   Dali::Vector2 *arg1 = 0 ;
5461   Dali::Vector2 *arg2 = 0 ;
5462   Dali::Vector2 result;
5463
5464   arg1 = (Dali::Vector2 *)jarg1;
5465   if (!arg1) {
5466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5467     return 0;
5468   }
5469   arg2 = (Dali::Vector2 *)jarg2;
5470   if (!arg2) {
5471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5472     return 0;
5473   }
5474   {
5475     try {
5476       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5477     } catch (std::out_of_range& e) {
5478       {
5479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5480       };
5481     } catch (std::exception& e) {
5482       {
5483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5484       };
5485     } catch (Dali::DaliException e) {
5486       {
5487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5488       };
5489     } catch (...) {
5490       {
5491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5492       };
5493     }
5494   }
5495
5496   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5497   return jresult;
5498 }
5499
5500
5501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5502   void * jresult ;
5503   Dali::Vector2 *arg1 = 0 ;
5504   Dali::Vector2 *arg2 = 0 ;
5505   Dali::Vector2 result;
5506
5507   arg1 = (Dali::Vector2 *)jarg1;
5508   if (!arg1) {
5509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5510     return 0;
5511   }
5512   arg2 = (Dali::Vector2 *)jarg2;
5513   if (!arg2) {
5514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5515     return 0;
5516   }
5517   {
5518     try {
5519       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5520     } catch (std::out_of_range& e) {
5521       {
5522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5523       };
5524     } catch (std::exception& e) {
5525       {
5526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5527       };
5528     } catch (Dali::DaliException e) {
5529       {
5530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5531       };
5532     } catch (...) {
5533       {
5534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5535       };
5536     }
5537   }
5538
5539   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5540   return jresult;
5541 }
5542
5543
5544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5545   void * jresult ;
5546   Dali::Vector2 *arg1 = 0 ;
5547   float *arg2 = 0 ;
5548   float *arg3 = 0 ;
5549   float temp2 ;
5550   float temp3 ;
5551   Dali::Vector2 result;
5552
5553   arg1 = (Dali::Vector2 *)jarg1;
5554   if (!arg1) {
5555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5556     return 0;
5557   }
5558   temp2 = (float)jarg2;
5559   arg2 = &temp2;
5560   temp3 = (float)jarg3;
5561   arg3 = &temp3;
5562   {
5563     try {
5564       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5565     } catch (std::out_of_range& e) {
5566       {
5567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5568       };
5569     } catch (std::exception& e) {
5570       {
5571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5572       };
5573     } catch (Dali::DaliException e) {
5574       {
5575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5576       };
5577     } catch (...) {
5578       {
5579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5580       };
5581     }
5582   }
5583
5584   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5585   return jresult;
5586 }
5587
5588
5589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5590   void * jresult ;
5591   Dali::Vector3 *result = 0 ;
5592
5593   {
5594     try {
5595       result = (Dali::Vector3 *)new Dali::Vector3();
5596     } catch (std::out_of_range& e) {
5597       {
5598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5599       };
5600     } catch (std::exception& e) {
5601       {
5602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5603       };
5604     } catch (Dali::DaliException e) {
5605       {
5606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5607       };
5608     } catch (...) {
5609       {
5610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5611       };
5612     }
5613   }
5614
5615   jresult = (void *)result;
5616   return jresult;
5617 }
5618
5619
5620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5621   void * jresult ;
5622   float arg1 ;
5623   float arg2 ;
5624   float arg3 ;
5625   Dali::Vector3 *result = 0 ;
5626
5627   arg1 = (float)jarg1;
5628   arg2 = (float)jarg2;
5629   arg3 = (float)jarg3;
5630   {
5631     try {
5632       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5633     } catch (std::out_of_range& e) {
5634       {
5635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5636       };
5637     } catch (std::exception& e) {
5638       {
5639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5640       };
5641     } catch (Dali::DaliException e) {
5642       {
5643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5644       };
5645     } catch (...) {
5646       {
5647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5648       };
5649     }
5650   }
5651
5652   jresult = (void *)result;
5653   return jresult;
5654 }
5655
5656
5657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5658   void * jresult ;
5659   float *arg1 = (float *) 0 ;
5660   Dali::Vector3 *result = 0 ;
5661
5662   arg1 = jarg1;
5663   {
5664     try {
5665       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5666     } catch (std::out_of_range& e) {
5667       {
5668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5669       };
5670     } catch (std::exception& e) {
5671       {
5672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5673       };
5674     } catch (Dali::DaliException e) {
5675       {
5676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5677       };
5678     } catch (...) {
5679       {
5680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5681       };
5682     }
5683   }
5684
5685   jresult = (void *)result;
5686
5687
5688   return jresult;
5689 }
5690
5691
5692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5693   void * jresult ;
5694   Dali::Vector2 *arg1 = 0 ;
5695   Dali::Vector3 *result = 0 ;
5696
5697   arg1 = (Dali::Vector2 *)jarg1;
5698   if (!arg1) {
5699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5700     return 0;
5701   }
5702   {
5703     try {
5704       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5705     } catch (std::out_of_range& e) {
5706       {
5707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5708       };
5709     } catch (std::exception& e) {
5710       {
5711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5712       };
5713     } catch (Dali::DaliException e) {
5714       {
5715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5716       };
5717     } catch (...) {
5718       {
5719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5720       };
5721     }
5722   }
5723
5724   jresult = (void *)result;
5725   return jresult;
5726 }
5727
5728
5729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5730   void * jresult ;
5731   Dali::Vector4 *arg1 = 0 ;
5732   Dali::Vector3 *result = 0 ;
5733
5734   arg1 = (Dali::Vector4 *)jarg1;
5735   if (!arg1) {
5736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5737     return 0;
5738   }
5739   {
5740     try {
5741       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5742     } catch (std::out_of_range& e) {
5743       {
5744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5745       };
5746     } catch (std::exception& e) {
5747       {
5748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5749       };
5750     } catch (Dali::DaliException e) {
5751       {
5752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5753       };
5754     } catch (...) {
5755       {
5756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5757       };
5758     }
5759   }
5760
5761   jresult = (void *)result;
5762   return jresult;
5763 }
5764
5765
5766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5767   void * jresult ;
5768   Dali::Vector3 *result = 0 ;
5769
5770   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5771   jresult = (void *)result;
5772   return jresult;
5773 }
5774
5775
5776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5777   void * jresult ;
5778   Dali::Vector3 *result = 0 ;
5779
5780   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5781   jresult = (void *)result;
5782   return jresult;
5783 }
5784
5785
5786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5787   void * jresult ;
5788   Dali::Vector3 *result = 0 ;
5789
5790   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5791   jresult = (void *)result;
5792   return jresult;
5793 }
5794
5795
5796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5797   void * jresult ;
5798   Dali::Vector3 *result = 0 ;
5799
5800   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5801   jresult = (void *)result;
5802   return jresult;
5803 }
5804
5805
5806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5807   void * jresult ;
5808   Dali::Vector3 *result = 0 ;
5809
5810   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5811   jresult = (void *)result;
5812   return jresult;
5813 }
5814
5815
5816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5817   void * jresult ;
5818   Dali::Vector3 *result = 0 ;
5819
5820   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5821   jresult = (void *)result;
5822   return jresult;
5823 }
5824
5825
5826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5827   void * jresult ;
5828   Dali::Vector3 *result = 0 ;
5829
5830   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5831   jresult = (void *)result;
5832   return jresult;
5833 }
5834
5835
5836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5837   void * jresult ;
5838   Dali::Vector3 *result = 0 ;
5839
5840   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5841   jresult = (void *)result;
5842   return jresult;
5843 }
5844
5845
5846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5847   void * jresult ;
5848   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5849   float *arg2 = (float *) 0 ;
5850   Dali::Vector3 *result = 0 ;
5851
5852   arg1 = (Dali::Vector3 *)jarg1;
5853   arg2 = jarg2;
5854   {
5855     try {
5856       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5857     } catch (std::out_of_range& e) {
5858       {
5859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5860       };
5861     } catch (std::exception& e) {
5862       {
5863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5864       };
5865     } catch (Dali::DaliException e) {
5866       {
5867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5868       };
5869     } catch (...) {
5870       {
5871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5872       };
5873     }
5874   }
5875
5876   jresult = (void *)result;
5877
5878
5879   return jresult;
5880 }
5881
5882
5883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5884   void * jresult ;
5885   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5886   Dali::Vector2 *arg2 = 0 ;
5887   Dali::Vector3 *result = 0 ;
5888
5889   arg1 = (Dali::Vector3 *)jarg1;
5890   arg2 = (Dali::Vector2 *)jarg2;
5891   if (!arg2) {
5892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5893     return 0;
5894   }
5895   {
5896     try {
5897       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5898     } catch (std::out_of_range& e) {
5899       {
5900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5901       };
5902     } catch (std::exception& e) {
5903       {
5904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5905       };
5906     } catch (Dali::DaliException e) {
5907       {
5908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5909       };
5910     } catch (...) {
5911       {
5912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5913       };
5914     }
5915   }
5916
5917   jresult = (void *)result;
5918   return jresult;
5919 }
5920
5921
5922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5923   void * jresult ;
5924   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5925   Dali::Vector4 *arg2 = 0 ;
5926   Dali::Vector3 *result = 0 ;
5927
5928   arg1 = (Dali::Vector3 *)jarg1;
5929   arg2 = (Dali::Vector4 *)jarg2;
5930   if (!arg2) {
5931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5932     return 0;
5933   }
5934   {
5935     try {
5936       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5937     } catch (std::out_of_range& e) {
5938       {
5939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5940       };
5941     } catch (std::exception& e) {
5942       {
5943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5944       };
5945     } catch (Dali::DaliException e) {
5946       {
5947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5948       };
5949     } catch (...) {
5950       {
5951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5952       };
5953     }
5954   }
5955
5956   jresult = (void *)result;
5957   return jresult;
5958 }
5959
5960
5961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5962   void * jresult ;
5963   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5964   Dali::Vector3 *arg2 = 0 ;
5965   Dali::Vector3 result;
5966
5967   arg1 = (Dali::Vector3 *)jarg1;
5968   arg2 = (Dali::Vector3 *)jarg2;
5969   if (!arg2) {
5970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5971     return 0;
5972   }
5973   {
5974     try {
5975       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5976     } catch (std::out_of_range& e) {
5977       {
5978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5979       };
5980     } catch (std::exception& e) {
5981       {
5982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5983       };
5984     } catch (Dali::DaliException e) {
5985       {
5986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5987       };
5988     } catch (...) {
5989       {
5990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5991       };
5992     }
5993   }
5994
5995   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5996   return jresult;
5997 }
5998
5999
6000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
6001   void * jresult ;
6002   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6003   Dali::Vector3 *arg2 = 0 ;
6004   Dali::Vector3 *result = 0 ;
6005
6006   arg1 = (Dali::Vector3 *)jarg1;
6007   arg2 = (Dali::Vector3 *)jarg2;
6008   if (!arg2) {
6009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6010     return 0;
6011   }
6012   {
6013     try {
6014       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6015     } catch (std::out_of_range& e) {
6016       {
6017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6018       };
6019     } catch (std::exception& e) {
6020       {
6021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6022       };
6023     } catch (Dali::DaliException e) {
6024       {
6025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6026       };
6027     } catch (...) {
6028       {
6029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6030       };
6031     }
6032   }
6033
6034   jresult = (void *)result;
6035   return jresult;
6036 }
6037
6038
6039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6040   void * jresult ;
6041   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6042   Dali::Vector3 *arg2 = 0 ;
6043   Dali::Vector3 result;
6044
6045   arg1 = (Dali::Vector3 *)jarg1;
6046   arg2 = (Dali::Vector3 *)jarg2;
6047   if (!arg2) {
6048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6049     return 0;
6050   }
6051   {
6052     try {
6053       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6054     } catch (std::out_of_range& e) {
6055       {
6056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6057       };
6058     } catch (std::exception& e) {
6059       {
6060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6061       };
6062     } catch (Dali::DaliException e) {
6063       {
6064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6065       };
6066     } catch (...) {
6067       {
6068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6069       };
6070     }
6071   }
6072
6073   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6074   return jresult;
6075 }
6076
6077
6078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6079   void * jresult ;
6080   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6081   Dali::Vector3 *arg2 = 0 ;
6082   Dali::Vector3 *result = 0 ;
6083
6084   arg1 = (Dali::Vector3 *)jarg1;
6085   arg2 = (Dali::Vector3 *)jarg2;
6086   if (!arg2) {
6087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6088     return 0;
6089   }
6090   {
6091     try {
6092       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6093     } catch (std::out_of_range& e) {
6094       {
6095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6096       };
6097     } catch (std::exception& e) {
6098       {
6099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6100       };
6101     } catch (Dali::DaliException e) {
6102       {
6103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6104       };
6105     } catch (...) {
6106       {
6107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6108       };
6109     }
6110   }
6111
6112   jresult = (void *)result;
6113   return jresult;
6114 }
6115
6116
6117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6118   void * jresult ;
6119   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6120   Dali::Vector3 *arg2 = 0 ;
6121   Dali::Vector3 result;
6122
6123   arg1 = (Dali::Vector3 *)jarg1;
6124   arg2 = (Dali::Vector3 *)jarg2;
6125   if (!arg2) {
6126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6127     return 0;
6128   }
6129   {
6130     try {
6131       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6132     } catch (std::out_of_range& e) {
6133       {
6134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6135       };
6136     } catch (std::exception& e) {
6137       {
6138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6139       };
6140     } catch (Dali::DaliException e) {
6141       {
6142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6143       };
6144     } catch (...) {
6145       {
6146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6147       };
6148     }
6149   }
6150
6151   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6152   return jresult;
6153 }
6154
6155
6156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6157   void * jresult ;
6158   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6159   float arg2 ;
6160   Dali::Vector3 result;
6161
6162   arg1 = (Dali::Vector3 *)jarg1;
6163   arg2 = (float)jarg2;
6164   {
6165     try {
6166       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6167     } catch (std::out_of_range& e) {
6168       {
6169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6170       };
6171     } catch (std::exception& e) {
6172       {
6173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6174       };
6175     } catch (Dali::DaliException e) {
6176       {
6177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6178       };
6179     } catch (...) {
6180       {
6181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6182       };
6183     }
6184   }
6185
6186   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6187   return jresult;
6188 }
6189
6190
6191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6192   void * jresult ;
6193   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6194   Dali::Vector3 *arg2 = 0 ;
6195   Dali::Vector3 *result = 0 ;
6196
6197   arg1 = (Dali::Vector3 *)jarg1;
6198   arg2 = (Dali::Vector3 *)jarg2;
6199   if (!arg2) {
6200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6201     return 0;
6202   }
6203   {
6204     try {
6205       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6206     } catch (std::out_of_range& e) {
6207       {
6208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6209       };
6210     } catch (std::exception& e) {
6211       {
6212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6213       };
6214     } catch (Dali::DaliException e) {
6215       {
6216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6217       };
6218     } catch (...) {
6219       {
6220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6221       };
6222     }
6223   }
6224
6225   jresult = (void *)result;
6226   return jresult;
6227 }
6228
6229
6230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6231   void * jresult ;
6232   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6233   float arg2 ;
6234   Dali::Vector3 *result = 0 ;
6235
6236   arg1 = (Dali::Vector3 *)jarg1;
6237   arg2 = (float)jarg2;
6238   {
6239     try {
6240       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6241     } catch (std::out_of_range& e) {
6242       {
6243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6244       };
6245     } catch (std::exception& e) {
6246       {
6247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6248       };
6249     } catch (Dali::DaliException e) {
6250       {
6251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6252       };
6253     } catch (...) {
6254       {
6255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6256       };
6257     }
6258   }
6259
6260   jresult = (void *)result;
6261   return jresult;
6262 }
6263
6264
6265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6266   void * jresult ;
6267   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6268   Dali::Quaternion *arg2 = 0 ;
6269   Dali::Vector3 *result = 0 ;
6270
6271   arg1 = (Dali::Vector3 *)jarg1;
6272   arg2 = (Dali::Quaternion *)jarg2;
6273   if (!arg2) {
6274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6275     return 0;
6276   }
6277   {
6278     try {
6279       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6280     } catch (std::out_of_range& e) {
6281       {
6282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6283       };
6284     } catch (std::exception& e) {
6285       {
6286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6287       };
6288     } catch (Dali::DaliException e) {
6289       {
6290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6291       };
6292     } catch (...) {
6293       {
6294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6295       };
6296     }
6297   }
6298
6299   jresult = (void *)result;
6300   return jresult;
6301 }
6302
6303
6304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6305   void * jresult ;
6306   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6307   Dali::Vector3 *arg2 = 0 ;
6308   Dali::Vector3 result;
6309
6310   arg1 = (Dali::Vector3 *)jarg1;
6311   arg2 = (Dali::Vector3 *)jarg2;
6312   if (!arg2) {
6313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6314     return 0;
6315   }
6316   {
6317     try {
6318       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6319     } catch (std::out_of_range& e) {
6320       {
6321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6322       };
6323     } catch (std::exception& e) {
6324       {
6325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6326       };
6327     } catch (Dali::DaliException e) {
6328       {
6329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6330       };
6331     } catch (...) {
6332       {
6333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6334       };
6335     }
6336   }
6337
6338   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6339   return jresult;
6340 }
6341
6342
6343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6344   void * jresult ;
6345   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6346   float arg2 ;
6347   Dali::Vector3 result;
6348
6349   arg1 = (Dali::Vector3 *)jarg1;
6350   arg2 = (float)jarg2;
6351   {
6352     try {
6353       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6354     } catch (std::out_of_range& e) {
6355       {
6356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6357       };
6358     } catch (std::exception& e) {
6359       {
6360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6361       };
6362     } catch (Dali::DaliException e) {
6363       {
6364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6365       };
6366     } catch (...) {
6367       {
6368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6369       };
6370     }
6371   }
6372
6373   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6374   return jresult;
6375 }
6376
6377
6378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6379   void * jresult ;
6380   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6381   Dali::Vector3 *arg2 = 0 ;
6382   Dali::Vector3 *result = 0 ;
6383
6384   arg1 = (Dali::Vector3 *)jarg1;
6385   arg2 = (Dali::Vector3 *)jarg2;
6386   if (!arg2) {
6387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6388     return 0;
6389   }
6390   {
6391     try {
6392       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6393     } catch (std::out_of_range& e) {
6394       {
6395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6396       };
6397     } catch (std::exception& e) {
6398       {
6399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6400       };
6401     } catch (Dali::DaliException e) {
6402       {
6403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6404       };
6405     } catch (...) {
6406       {
6407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6408       };
6409     }
6410   }
6411
6412   jresult = (void *)result;
6413   return jresult;
6414 }
6415
6416
6417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6418   void * jresult ;
6419   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6420   float arg2 ;
6421   Dali::Vector3 *result = 0 ;
6422
6423   arg1 = (Dali::Vector3 *)jarg1;
6424   arg2 = (float)jarg2;
6425   {
6426     try {
6427       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6428     } catch (std::out_of_range& e) {
6429       {
6430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6431       };
6432     } catch (std::exception& e) {
6433       {
6434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6435       };
6436     } catch (Dali::DaliException e) {
6437       {
6438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6439       };
6440     } catch (...) {
6441       {
6442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6443       };
6444     }
6445   }
6446
6447   jresult = (void *)result;
6448   return jresult;
6449 }
6450
6451
6452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6453   void * jresult ;
6454   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6455   Dali::Vector3 result;
6456
6457   arg1 = (Dali::Vector3 *)jarg1;
6458   {
6459     try {
6460       result = ((Dali::Vector3 const *)arg1)->operator -();
6461     } catch (std::out_of_range& e) {
6462       {
6463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6464       };
6465     } catch (std::exception& e) {
6466       {
6467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6468       };
6469     } catch (Dali::DaliException e) {
6470       {
6471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6472       };
6473     } catch (...) {
6474       {
6475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6476       };
6477     }
6478   }
6479
6480   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6481   return jresult;
6482 }
6483
6484
6485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6486   unsigned int jresult ;
6487   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6488   Dali::Vector3 *arg2 = 0 ;
6489   bool result;
6490
6491   arg1 = (Dali::Vector3 *)jarg1;
6492   arg2 = (Dali::Vector3 *)jarg2;
6493   if (!arg2) {
6494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6495     return 0;
6496   }
6497   {
6498     try {
6499       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6500     } catch (std::out_of_range& e) {
6501       {
6502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6503       };
6504     } catch (std::exception& e) {
6505       {
6506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6507       };
6508     } catch (Dali::DaliException e) {
6509       {
6510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6511       };
6512     } catch (...) {
6513       {
6514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6515       };
6516     }
6517   }
6518
6519   jresult = result;
6520   return jresult;
6521 }
6522
6523
6524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6525   unsigned int jresult ;
6526   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6527   Dali::Vector3 *arg2 = 0 ;
6528   bool result;
6529
6530   arg1 = (Dali::Vector3 *)jarg1;
6531   arg2 = (Dali::Vector3 *)jarg2;
6532   if (!arg2) {
6533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6534     return 0;
6535   }
6536   {
6537     try {
6538       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6539     } catch (std::out_of_range& e) {
6540       {
6541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6542       };
6543     } catch (std::exception& e) {
6544       {
6545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6546       };
6547     } catch (Dali::DaliException e) {
6548       {
6549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6550       };
6551     } catch (...) {
6552       {
6553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6554       };
6555     }
6556   }
6557
6558   jresult = result;
6559   return jresult;
6560 }
6561
6562
6563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6564   float jresult ;
6565   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6566   unsigned int arg2 ;
6567   float *result = 0 ;
6568
6569   arg1 = (Dali::Vector3 *)jarg1;
6570   arg2 = (unsigned int)jarg2;
6571   {
6572     try {
6573       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6574     } catch (std::out_of_range& e) {
6575       {
6576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6577       };
6578     } catch (std::exception& e) {
6579       {
6580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6581       };
6582     } catch (Dali::DaliException e) {
6583       {
6584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6585       };
6586     } catch (...) {
6587       {
6588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6589       };
6590     }
6591   }
6592
6593   jresult = *result;
6594   return jresult;
6595 }
6596
6597
6598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6599   float jresult ;
6600   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6601   Dali::Vector3 *arg2 = 0 ;
6602   float result;
6603
6604   arg1 = (Dali::Vector3 *)jarg1;
6605   arg2 = (Dali::Vector3 *)jarg2;
6606   if (!arg2) {
6607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6608     return 0;
6609   }
6610   {
6611     try {
6612       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6613     } catch (std::out_of_range& e) {
6614       {
6615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6616       };
6617     } catch (std::exception& e) {
6618       {
6619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6620       };
6621     } catch (Dali::DaliException e) {
6622       {
6623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6624       };
6625     } catch (...) {
6626       {
6627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6628       };
6629     }
6630   }
6631
6632   jresult = result;
6633   return jresult;
6634 }
6635
6636
6637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6638   void * jresult ;
6639   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6640   Dali::Vector3 *arg2 = 0 ;
6641   Dali::Vector3 result;
6642
6643   arg1 = (Dali::Vector3 *)jarg1;
6644   arg2 = (Dali::Vector3 *)jarg2;
6645   if (!arg2) {
6646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6647     return 0;
6648   }
6649   {
6650     try {
6651       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6652     } catch (std::out_of_range& e) {
6653       {
6654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6655       };
6656     } catch (std::exception& e) {
6657       {
6658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6659       };
6660     } catch (Dali::DaliException e) {
6661       {
6662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6663       };
6664     } catch (...) {
6665       {
6666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6667       };
6668     }
6669   }
6670
6671   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6672   return jresult;
6673 }
6674
6675
6676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6677   float jresult ;
6678   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6679   float result;
6680
6681   arg1 = (Dali::Vector3 *)jarg1;
6682   {
6683     try {
6684       result = (float)((Dali::Vector3 const *)arg1)->Length();
6685     } catch (std::out_of_range& e) {
6686       {
6687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6688       };
6689     } catch (std::exception& e) {
6690       {
6691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6692       };
6693     } catch (Dali::DaliException e) {
6694       {
6695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6696       };
6697     } catch (...) {
6698       {
6699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6700       };
6701     }
6702   }
6703
6704   jresult = result;
6705   return jresult;
6706 }
6707
6708
6709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6710   float jresult ;
6711   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6712   float result;
6713
6714   arg1 = (Dali::Vector3 *)jarg1;
6715   {
6716     try {
6717       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6718     } catch (std::out_of_range& e) {
6719       {
6720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6721       };
6722     } catch (std::exception& e) {
6723       {
6724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6725       };
6726     } catch (Dali::DaliException e) {
6727       {
6728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6729       };
6730     } catch (...) {
6731       {
6732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6733       };
6734     }
6735   }
6736
6737   jresult = result;
6738   return jresult;
6739 }
6740
6741
6742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6743   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6744
6745   arg1 = (Dali::Vector3 *)jarg1;
6746   {
6747     try {
6748       (arg1)->Normalize();
6749     } catch (std::out_of_range& e) {
6750       {
6751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6752       };
6753     } catch (std::exception& e) {
6754       {
6755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6756       };
6757     } catch (Dali::DaliException e) {
6758       {
6759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6760       };
6761     } catch (...) {
6762       {
6763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6764       };
6765     }
6766   }
6767
6768 }
6769
6770
6771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6772   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6773   Dali::Vector3 *arg2 = 0 ;
6774   Dali::Vector3 *arg3 = 0 ;
6775
6776   arg1 = (Dali::Vector3 *)jarg1;
6777   arg2 = (Dali::Vector3 *)jarg2;
6778   if (!arg2) {
6779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6780     return ;
6781   }
6782   arg3 = (Dali::Vector3 *)jarg3;
6783   if (!arg3) {
6784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6785     return ;
6786   }
6787   {
6788     try {
6789       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6790     } catch (std::out_of_range& e) {
6791       {
6792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6793       };
6794     } catch (std::exception& e) {
6795       {
6796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6797       };
6798     } catch (Dali::DaliException e) {
6799       {
6800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6801       };
6802     } catch (...) {
6803       {
6804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6805       };
6806     }
6807   }
6808
6809 }
6810
6811
6812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6813   void * jresult ;
6814   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6815   float *result = 0 ;
6816
6817   arg1 = (Dali::Vector3 *)jarg1;
6818   {
6819     try {
6820       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6821     } catch (std::out_of_range& e) {
6822       {
6823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6824       };
6825     } catch (std::exception& e) {
6826       {
6827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6828       };
6829     } catch (Dali::DaliException e) {
6830       {
6831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6832       };
6833     } catch (...) {
6834       {
6835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6836       };
6837     }
6838   }
6839
6840   jresult = (void *)result;
6841   return jresult;
6842 }
6843
6844
6845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6846   void * jresult ;
6847   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6848   Dali::Vector2 *result = 0 ;
6849
6850   arg1 = (Dali::Vector3 *)jarg1;
6851   {
6852     try {
6853       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6854     } catch (std::out_of_range& e) {
6855       {
6856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6857       };
6858     } catch (std::exception& e) {
6859       {
6860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6861       };
6862     } catch (Dali::DaliException e) {
6863       {
6864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6865       };
6866     } catch (...) {
6867       {
6868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6869       };
6870     }
6871   }
6872
6873   jresult = (void *)result;
6874   return jresult;
6875 }
6876
6877
6878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6879   void * jresult ;
6880   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6881   Dali::Vector2 *result = 0 ;
6882
6883   arg1 = (Dali::Vector3 *)jarg1;
6884   {
6885     try {
6886       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6887     } catch (std::out_of_range& e) {
6888       {
6889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6890       };
6891     } catch (std::exception& e) {
6892       {
6893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6894       };
6895     } catch (Dali::DaliException e) {
6896       {
6897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6898       };
6899     } catch (...) {
6900       {
6901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6902       };
6903     }
6904   }
6905
6906   jresult = (void *)result;
6907   return jresult;
6908 }
6909
6910
6911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6912   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6913   float arg2 ;
6914
6915   arg1 = (Dali::Vector3 *)jarg1;
6916   arg2 = (float)jarg2;
6917   if (arg1) (arg1)->x = arg2;
6918 }
6919
6920
6921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6922   float jresult ;
6923   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6924   float result;
6925
6926   arg1 = (Dali::Vector3 *)jarg1;
6927   result = (float) ((arg1)->x);
6928   jresult = result;
6929   return jresult;
6930 }
6931
6932
6933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6934   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6935   float arg2 ;
6936
6937   arg1 = (Dali::Vector3 *)jarg1;
6938   arg2 = (float)jarg2;
6939   if (arg1) (arg1)->width = arg2;
6940 }
6941
6942
6943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6944   float jresult ;
6945   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6946   float result;
6947
6948   arg1 = (Dali::Vector3 *)jarg1;
6949   result = (float) ((arg1)->width);
6950   jresult = result;
6951   return jresult;
6952 }
6953
6954
6955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6956   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6957   float arg2 ;
6958
6959   arg1 = (Dali::Vector3 *)jarg1;
6960   arg2 = (float)jarg2;
6961   if (arg1) (arg1)->r = arg2;
6962 }
6963
6964
6965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6966   float jresult ;
6967   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6968   float result;
6969
6970   arg1 = (Dali::Vector3 *)jarg1;
6971   result = (float) ((arg1)->r);
6972   jresult = result;
6973   return jresult;
6974 }
6975
6976
6977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6978   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6979   float arg2 ;
6980
6981   arg1 = (Dali::Vector3 *)jarg1;
6982   arg2 = (float)jarg2;
6983   if (arg1) (arg1)->y = arg2;
6984 }
6985
6986
6987 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6988   float jresult ;
6989   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6990   float result;
6991
6992   arg1 = (Dali::Vector3 *)jarg1;
6993   result = (float) ((arg1)->y);
6994   jresult = result;
6995   return jresult;
6996 }
6997
6998
6999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
7000   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7001   float arg2 ;
7002
7003   arg1 = (Dali::Vector3 *)jarg1;
7004   arg2 = (float)jarg2;
7005   if (arg1) (arg1)->height = arg2;
7006 }
7007
7008
7009 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7010   float jresult ;
7011   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7012   float result;
7013
7014   arg1 = (Dali::Vector3 *)jarg1;
7015   result = (float) ((arg1)->height);
7016   jresult = result;
7017   return jresult;
7018 }
7019
7020
7021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7022   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7023   float arg2 ;
7024
7025   arg1 = (Dali::Vector3 *)jarg1;
7026   arg2 = (float)jarg2;
7027   if (arg1) (arg1)->g = arg2;
7028 }
7029
7030
7031 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7032   float jresult ;
7033   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7034   float result;
7035
7036   arg1 = (Dali::Vector3 *)jarg1;
7037   result = (float) ((arg1)->g);
7038   jresult = result;
7039   return jresult;
7040 }
7041
7042
7043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7044   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7045   float arg2 ;
7046
7047   arg1 = (Dali::Vector3 *)jarg1;
7048   arg2 = (float)jarg2;
7049   if (arg1) (arg1)->z = arg2;
7050 }
7051
7052
7053 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7054   float jresult ;
7055   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7056   float result;
7057
7058   arg1 = (Dali::Vector3 *)jarg1;
7059   result = (float) ((arg1)->z);
7060   jresult = result;
7061   return jresult;
7062 }
7063
7064
7065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7066   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7067   float arg2 ;
7068
7069   arg1 = (Dali::Vector3 *)jarg1;
7070   arg2 = (float)jarg2;
7071   if (arg1) (arg1)->depth = arg2;
7072 }
7073
7074
7075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7076   float jresult ;
7077   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7078   float result;
7079
7080   arg1 = (Dali::Vector3 *)jarg1;
7081   result = (float) ((arg1)->depth);
7082   jresult = result;
7083   return jresult;
7084 }
7085
7086
7087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7088   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7089   float arg2 ;
7090
7091   arg1 = (Dali::Vector3 *)jarg1;
7092   arg2 = (float)jarg2;
7093   if (arg1) (arg1)->b = arg2;
7094 }
7095
7096
7097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7098   float jresult ;
7099   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7100   float result;
7101
7102   arg1 = (Dali::Vector3 *)jarg1;
7103   result = (float) ((arg1)->b);
7104   jresult = result;
7105   return jresult;
7106 }
7107
7108
7109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7110   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7111
7112   arg1 = (Dali::Vector3 *)jarg1;
7113   {
7114     try {
7115       delete arg1;
7116     } catch (std::out_of_range& e) {
7117       {
7118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7119       };
7120     } catch (std::exception& e) {
7121       {
7122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7123       };
7124     } catch (Dali::DaliException e) {
7125       {
7126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7127       };
7128     } catch (...) {
7129       {
7130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7131       };
7132     }
7133   }
7134
7135 }
7136
7137
7138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7139   void * jresult ;
7140   Dali::Vector3 *arg1 = 0 ;
7141   Dali::Vector3 *arg2 = 0 ;
7142   Dali::Vector3 result;
7143
7144   arg1 = (Dali::Vector3 *)jarg1;
7145   if (!arg1) {
7146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7147     return 0;
7148   }
7149   arg2 = (Dali::Vector3 *)jarg2;
7150   if (!arg2) {
7151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7152     return 0;
7153   }
7154   {
7155     try {
7156       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7157     } catch (std::out_of_range& e) {
7158       {
7159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7160       };
7161     } catch (std::exception& e) {
7162       {
7163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7164       };
7165     } catch (Dali::DaliException e) {
7166       {
7167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7168       };
7169     } catch (...) {
7170       {
7171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7172       };
7173     }
7174   }
7175
7176   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7177   return jresult;
7178 }
7179
7180
7181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7182   void * jresult ;
7183   Dali::Vector3 *arg1 = 0 ;
7184   Dali::Vector3 *arg2 = 0 ;
7185   Dali::Vector3 result;
7186
7187   arg1 = (Dali::Vector3 *)jarg1;
7188   if (!arg1) {
7189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7190     return 0;
7191   }
7192   arg2 = (Dali::Vector3 *)jarg2;
7193   if (!arg2) {
7194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7195     return 0;
7196   }
7197   {
7198     try {
7199       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7200     } catch (std::out_of_range& e) {
7201       {
7202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7203       };
7204     } catch (std::exception& e) {
7205       {
7206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7207       };
7208     } catch (Dali::DaliException e) {
7209       {
7210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7211       };
7212     } catch (...) {
7213       {
7214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7215       };
7216     }
7217   }
7218
7219   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7220   return jresult;
7221 }
7222
7223
7224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7225   void * jresult ;
7226   Dali::Vector3 *arg1 = 0 ;
7227   float *arg2 = 0 ;
7228   float *arg3 = 0 ;
7229   float temp2 ;
7230   float temp3 ;
7231   Dali::Vector3 result;
7232
7233   arg1 = (Dali::Vector3 *)jarg1;
7234   if (!arg1) {
7235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7236     return 0;
7237   }
7238   temp2 = (float)jarg2;
7239   arg2 = &temp2;
7240   temp3 = (float)jarg3;
7241   arg3 = &temp3;
7242   {
7243     try {
7244       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7245     } catch (std::out_of_range& e) {
7246       {
7247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7248       };
7249     } catch (std::exception& e) {
7250       {
7251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7252       };
7253     } catch (Dali::DaliException e) {
7254       {
7255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7256       };
7257     } catch (...) {
7258       {
7259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7260       };
7261     }
7262   }
7263
7264   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7265   return jresult;
7266 }
7267
7268
7269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7270   void * jresult ;
7271   Dali::Vector4 *result = 0 ;
7272
7273   {
7274     try {
7275       result = (Dali::Vector4 *)new Dali::Vector4();
7276     } catch (std::out_of_range& e) {
7277       {
7278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7279       };
7280     } catch (std::exception& e) {
7281       {
7282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7283       };
7284     } catch (Dali::DaliException e) {
7285       {
7286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7287       };
7288     } catch (...) {
7289       {
7290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7291       };
7292     }
7293   }
7294
7295   jresult = (void *)result;
7296   return jresult;
7297 }
7298
7299
7300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7301   void * jresult ;
7302   float arg1 ;
7303   float arg2 ;
7304   float arg3 ;
7305   float arg4 ;
7306   Dali::Vector4 *result = 0 ;
7307
7308   arg1 = (float)jarg1;
7309   arg2 = (float)jarg2;
7310   arg3 = (float)jarg3;
7311   arg4 = (float)jarg4;
7312   {
7313     try {
7314       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7315     } catch (std::out_of_range& e) {
7316       {
7317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7318       };
7319     } catch (std::exception& e) {
7320       {
7321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7322       };
7323     } catch (Dali::DaliException e) {
7324       {
7325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7326       };
7327     } catch (...) {
7328       {
7329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7330       };
7331     }
7332   }
7333
7334   jresult = (void *)result;
7335   return jresult;
7336 }
7337
7338
7339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7340   void * jresult ;
7341   float *arg1 = (float *) 0 ;
7342   Dali::Vector4 *result = 0 ;
7343
7344   arg1 = jarg1;
7345   {
7346     try {
7347       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7348     } catch (std::out_of_range& e) {
7349       {
7350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7351       };
7352     } catch (std::exception& e) {
7353       {
7354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7355       };
7356     } catch (Dali::DaliException e) {
7357       {
7358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7359       };
7360     } catch (...) {
7361       {
7362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7363       };
7364     }
7365   }
7366
7367   jresult = (void *)result;
7368
7369
7370   return jresult;
7371 }
7372
7373
7374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7375   void * jresult ;
7376   Dali::Vector2 *arg1 = 0 ;
7377   Dali::Vector4 *result = 0 ;
7378
7379   arg1 = (Dali::Vector2 *)jarg1;
7380   if (!arg1) {
7381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7382     return 0;
7383   }
7384   {
7385     try {
7386       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7387     } catch (std::out_of_range& e) {
7388       {
7389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7390       };
7391     } catch (std::exception& e) {
7392       {
7393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7394       };
7395     } catch (Dali::DaliException e) {
7396       {
7397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7398       };
7399     } catch (...) {
7400       {
7401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7402       };
7403     }
7404   }
7405
7406   jresult = (void *)result;
7407   return jresult;
7408 }
7409
7410
7411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7412   void * jresult ;
7413   Dali::Vector3 *arg1 = 0 ;
7414   Dali::Vector4 *result = 0 ;
7415
7416   arg1 = (Dali::Vector3 *)jarg1;
7417   if (!arg1) {
7418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7419     return 0;
7420   }
7421   {
7422     try {
7423       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7424     } catch (std::out_of_range& e) {
7425       {
7426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7427       };
7428     } catch (std::exception& e) {
7429       {
7430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7431       };
7432     } catch (Dali::DaliException e) {
7433       {
7434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7435       };
7436     } catch (...) {
7437       {
7438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7439       };
7440     }
7441   }
7442
7443   jresult = (void *)result;
7444   return jresult;
7445 }
7446
7447
7448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7449   void * jresult ;
7450   Dali::Vector4 *result = 0 ;
7451
7452   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7453   jresult = (void *)result;
7454   return jresult;
7455 }
7456
7457
7458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7459   void * jresult ;
7460   Dali::Vector4 *result = 0 ;
7461
7462   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7463   jresult = (void *)result;
7464   return jresult;
7465 }
7466
7467
7468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7469   void * jresult ;
7470   Dali::Vector4 *result = 0 ;
7471
7472   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7473   jresult = (void *)result;
7474   return jresult;
7475 }
7476
7477
7478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7479   void * jresult ;
7480   Dali::Vector4 *result = 0 ;
7481
7482   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7483   jresult = (void *)result;
7484   return jresult;
7485 }
7486
7487
7488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7489   void * jresult ;
7490   Dali::Vector4 *result = 0 ;
7491
7492   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7493   jresult = (void *)result;
7494   return jresult;
7495 }
7496
7497
7498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7499   void * jresult ;
7500   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7501   float *arg2 = (float *) 0 ;
7502   Dali::Vector4 *result = 0 ;
7503
7504   arg1 = (Dali::Vector4 *)jarg1;
7505   arg2 = jarg2;
7506   {
7507     try {
7508       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7509     } catch (std::out_of_range& e) {
7510       {
7511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7512       };
7513     } catch (std::exception& e) {
7514       {
7515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7516       };
7517     } catch (Dali::DaliException e) {
7518       {
7519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7520       };
7521     } catch (...) {
7522       {
7523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7524       };
7525     }
7526   }
7527
7528   jresult = (void *)result;
7529
7530
7531   return jresult;
7532 }
7533
7534
7535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7536   void * jresult ;
7537   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7538   Dali::Vector2 *arg2 = 0 ;
7539   Dali::Vector4 *result = 0 ;
7540
7541   arg1 = (Dali::Vector4 *)jarg1;
7542   arg2 = (Dali::Vector2 *)jarg2;
7543   if (!arg2) {
7544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7545     return 0;
7546   }
7547   {
7548     try {
7549       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7550     } catch (std::out_of_range& e) {
7551       {
7552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7553       };
7554     } catch (std::exception& e) {
7555       {
7556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7557       };
7558     } catch (Dali::DaliException e) {
7559       {
7560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7561       };
7562     } catch (...) {
7563       {
7564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7565       };
7566     }
7567   }
7568
7569   jresult = (void *)result;
7570   return jresult;
7571 }
7572
7573
7574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7575   void * jresult ;
7576   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7577   Dali::Vector3 *arg2 = 0 ;
7578   Dali::Vector4 *result = 0 ;
7579
7580   arg1 = (Dali::Vector4 *)jarg1;
7581   arg2 = (Dali::Vector3 *)jarg2;
7582   if (!arg2) {
7583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7584     return 0;
7585   }
7586   {
7587     try {
7588       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7589     } catch (std::out_of_range& e) {
7590       {
7591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7592       };
7593     } catch (std::exception& e) {
7594       {
7595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7596       };
7597     } catch (Dali::DaliException e) {
7598       {
7599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7600       };
7601     } catch (...) {
7602       {
7603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7604       };
7605     }
7606   }
7607
7608   jresult = (void *)result;
7609   return jresult;
7610 }
7611
7612
7613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7614   void * jresult ;
7615   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7616   Dali::Vector4 *arg2 = 0 ;
7617   Dali::Vector4 result;
7618
7619   arg1 = (Dali::Vector4 *)jarg1;
7620   arg2 = (Dali::Vector4 *)jarg2;
7621   if (!arg2) {
7622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7623     return 0;
7624   }
7625   {
7626     try {
7627       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7628     } catch (std::out_of_range& e) {
7629       {
7630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7631       };
7632     } catch (std::exception& e) {
7633       {
7634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7635       };
7636     } catch (Dali::DaliException e) {
7637       {
7638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7639       };
7640     } catch (...) {
7641       {
7642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7643       };
7644     }
7645   }
7646
7647   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7648   return jresult;
7649 }
7650
7651
7652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7653   void * jresult ;
7654   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7655   Dali::Vector4 *arg2 = 0 ;
7656   Dali::Vector4 *result = 0 ;
7657
7658   arg1 = (Dali::Vector4 *)jarg1;
7659   arg2 = (Dali::Vector4 *)jarg2;
7660   if (!arg2) {
7661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7662     return 0;
7663   }
7664   {
7665     try {
7666       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7667     } catch (std::out_of_range& e) {
7668       {
7669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7670       };
7671     } catch (std::exception& e) {
7672       {
7673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7674       };
7675     } catch (Dali::DaliException e) {
7676       {
7677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7678       };
7679     } catch (...) {
7680       {
7681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7682       };
7683     }
7684   }
7685
7686   jresult = (void *)result;
7687   return jresult;
7688 }
7689
7690
7691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7692   void * jresult ;
7693   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7694   Dali::Vector4 *arg2 = 0 ;
7695   Dali::Vector4 result;
7696
7697   arg1 = (Dali::Vector4 *)jarg1;
7698   arg2 = (Dali::Vector4 *)jarg2;
7699   if (!arg2) {
7700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7701     return 0;
7702   }
7703   {
7704     try {
7705       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7706     } catch (std::out_of_range& e) {
7707       {
7708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7709       };
7710     } catch (std::exception& e) {
7711       {
7712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7713       };
7714     } catch (Dali::DaliException e) {
7715       {
7716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7717       };
7718     } catch (...) {
7719       {
7720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7721       };
7722     }
7723   }
7724
7725   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7726   return jresult;
7727 }
7728
7729
7730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7731   void * jresult ;
7732   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7733   Dali::Vector4 *arg2 = 0 ;
7734   Dali::Vector4 *result = 0 ;
7735
7736   arg1 = (Dali::Vector4 *)jarg1;
7737   arg2 = (Dali::Vector4 *)jarg2;
7738   if (!arg2) {
7739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7740     return 0;
7741   }
7742   {
7743     try {
7744       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7745     } catch (std::out_of_range& e) {
7746       {
7747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7748       };
7749     } catch (std::exception& e) {
7750       {
7751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7752       };
7753     } catch (Dali::DaliException e) {
7754       {
7755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7756       };
7757     } catch (...) {
7758       {
7759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7760       };
7761     }
7762   }
7763
7764   jresult = (void *)result;
7765   return jresult;
7766 }
7767
7768
7769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7770   void * jresult ;
7771   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7772   Dali::Vector4 *arg2 = 0 ;
7773   Dali::Vector4 result;
7774
7775   arg1 = (Dali::Vector4 *)jarg1;
7776   arg2 = (Dali::Vector4 *)jarg2;
7777   if (!arg2) {
7778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7779     return 0;
7780   }
7781   {
7782     try {
7783       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7784     } catch (std::out_of_range& e) {
7785       {
7786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7787       };
7788     } catch (std::exception& e) {
7789       {
7790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7791       };
7792     } catch (Dali::DaliException e) {
7793       {
7794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7795       };
7796     } catch (...) {
7797       {
7798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7799       };
7800     }
7801   }
7802
7803   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7804   return jresult;
7805 }
7806
7807
7808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7809   void * jresult ;
7810   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7811   float arg2 ;
7812   Dali::Vector4 result;
7813
7814   arg1 = (Dali::Vector4 *)jarg1;
7815   arg2 = (float)jarg2;
7816   {
7817     try {
7818       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7819     } catch (std::out_of_range& e) {
7820       {
7821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7822       };
7823     } catch (std::exception& e) {
7824       {
7825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7826       };
7827     } catch (Dali::DaliException e) {
7828       {
7829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7830       };
7831     } catch (...) {
7832       {
7833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7834       };
7835     }
7836   }
7837
7838   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7839   return jresult;
7840 }
7841
7842
7843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7844   void * jresult ;
7845   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7846   Dali::Vector4 *arg2 = 0 ;
7847   Dali::Vector4 *result = 0 ;
7848
7849   arg1 = (Dali::Vector4 *)jarg1;
7850   arg2 = (Dali::Vector4 *)jarg2;
7851   if (!arg2) {
7852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7853     return 0;
7854   }
7855   {
7856     try {
7857       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7858     } catch (std::out_of_range& e) {
7859       {
7860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7861       };
7862     } catch (std::exception& e) {
7863       {
7864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7865       };
7866     } catch (Dali::DaliException e) {
7867       {
7868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7869       };
7870     } catch (...) {
7871       {
7872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7873       };
7874     }
7875   }
7876
7877   jresult = (void *)result;
7878   return jresult;
7879 }
7880
7881
7882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7883   void * jresult ;
7884   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7885   float arg2 ;
7886   Dali::Vector4 *result = 0 ;
7887
7888   arg1 = (Dali::Vector4 *)jarg1;
7889   arg2 = (float)jarg2;
7890   {
7891     try {
7892       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7893     } catch (std::out_of_range& e) {
7894       {
7895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7896       };
7897     } catch (std::exception& e) {
7898       {
7899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7900       };
7901     } catch (Dali::DaliException e) {
7902       {
7903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7904       };
7905     } catch (...) {
7906       {
7907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7908       };
7909     }
7910   }
7911
7912   jresult = (void *)result;
7913   return jresult;
7914 }
7915
7916
7917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7918   void * jresult ;
7919   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7920   Dali::Vector4 *arg2 = 0 ;
7921   Dali::Vector4 result;
7922
7923   arg1 = (Dali::Vector4 *)jarg1;
7924   arg2 = (Dali::Vector4 *)jarg2;
7925   if (!arg2) {
7926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7927     return 0;
7928   }
7929   {
7930     try {
7931       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7932     } catch (std::out_of_range& e) {
7933       {
7934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7935       };
7936     } catch (std::exception& e) {
7937       {
7938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7939       };
7940     } catch (Dali::DaliException e) {
7941       {
7942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7943       };
7944     } catch (...) {
7945       {
7946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7947       };
7948     }
7949   }
7950
7951   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7952   return jresult;
7953 }
7954
7955
7956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7957   void * jresult ;
7958   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7959   float arg2 ;
7960   Dali::Vector4 result;
7961
7962   arg1 = (Dali::Vector4 *)jarg1;
7963   arg2 = (float)jarg2;
7964   {
7965     try {
7966       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7967     } catch (std::out_of_range& e) {
7968       {
7969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7970       };
7971     } catch (std::exception& e) {
7972       {
7973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7974       };
7975     } catch (Dali::DaliException e) {
7976       {
7977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7978       };
7979     } catch (...) {
7980       {
7981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7982       };
7983     }
7984   }
7985
7986   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7987   return jresult;
7988 }
7989
7990
7991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7992   void * jresult ;
7993   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7994   Dali::Vector4 *arg2 = 0 ;
7995   Dali::Vector4 *result = 0 ;
7996
7997   arg1 = (Dali::Vector4 *)jarg1;
7998   arg2 = (Dali::Vector4 *)jarg2;
7999   if (!arg2) {
8000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8001     return 0;
8002   }
8003   {
8004     try {
8005       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8006     } catch (std::out_of_range& e) {
8007       {
8008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8009       };
8010     } catch (std::exception& e) {
8011       {
8012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8013       };
8014     } catch (Dali::DaliException e) {
8015       {
8016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8017       };
8018     } catch (...) {
8019       {
8020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8021       };
8022     }
8023   }
8024
8025   jresult = (void *)result;
8026   return jresult;
8027 }
8028
8029
8030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8031   void * jresult ;
8032   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8033   float arg2 ;
8034   Dali::Vector4 *result = 0 ;
8035
8036   arg1 = (Dali::Vector4 *)jarg1;
8037   arg2 = (float)jarg2;
8038   {
8039     try {
8040       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8041     } catch (std::out_of_range& e) {
8042       {
8043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8044       };
8045     } catch (std::exception& e) {
8046       {
8047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8048       };
8049     } catch (Dali::DaliException e) {
8050       {
8051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8052       };
8053     } catch (...) {
8054       {
8055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8056       };
8057     }
8058   }
8059
8060   jresult = (void *)result;
8061   return jresult;
8062 }
8063
8064
8065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8066   void * jresult ;
8067   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8068   Dali::Vector4 result;
8069
8070   arg1 = (Dali::Vector4 *)jarg1;
8071   {
8072     try {
8073       result = ((Dali::Vector4 const *)arg1)->operator -();
8074     } catch (std::out_of_range& e) {
8075       {
8076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8077       };
8078     } catch (std::exception& e) {
8079       {
8080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8081       };
8082     } catch (Dali::DaliException e) {
8083       {
8084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8085       };
8086     } catch (...) {
8087       {
8088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8089       };
8090     }
8091   }
8092
8093   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8094   return jresult;
8095 }
8096
8097
8098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8099   unsigned int jresult ;
8100   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8101   Dali::Vector4 *arg2 = 0 ;
8102   bool result;
8103
8104   arg1 = (Dali::Vector4 *)jarg1;
8105   arg2 = (Dali::Vector4 *)jarg2;
8106   if (!arg2) {
8107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8108     return 0;
8109   }
8110   {
8111     try {
8112       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8113     } catch (std::out_of_range& e) {
8114       {
8115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8116       };
8117     } catch (std::exception& e) {
8118       {
8119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8120       };
8121     } catch (Dali::DaliException e) {
8122       {
8123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8124       };
8125     } catch (...) {
8126       {
8127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8128       };
8129     }
8130   }
8131
8132   jresult = result;
8133   return jresult;
8134 }
8135
8136
8137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8138   unsigned int jresult ;
8139   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8140   Dali::Vector4 *arg2 = 0 ;
8141   bool result;
8142
8143   arg1 = (Dali::Vector4 *)jarg1;
8144   arg2 = (Dali::Vector4 *)jarg2;
8145   if (!arg2) {
8146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8147     return 0;
8148   }
8149   {
8150     try {
8151       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8152     } catch (std::out_of_range& e) {
8153       {
8154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8155       };
8156     } catch (std::exception& e) {
8157       {
8158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8159       };
8160     } catch (Dali::DaliException e) {
8161       {
8162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8163       };
8164     } catch (...) {
8165       {
8166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8167       };
8168     }
8169   }
8170
8171   jresult = result;
8172   return jresult;
8173 }
8174
8175
8176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8177   float jresult ;
8178   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8179   unsigned int arg2 ;
8180   float *result = 0 ;
8181
8182   arg1 = (Dali::Vector4 *)jarg1;
8183   arg2 = (unsigned int)jarg2;
8184   {
8185     try {
8186       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8187     } catch (std::out_of_range& e) {
8188       {
8189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8190       };
8191     } catch (std::exception& e) {
8192       {
8193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8194       };
8195     } catch (Dali::DaliException e) {
8196       {
8197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8198       };
8199     } catch (...) {
8200       {
8201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8202       };
8203     }
8204   }
8205
8206   jresult = *result;
8207   return jresult;
8208 }
8209
8210
8211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8212   float jresult ;
8213   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8214   Dali::Vector3 *arg2 = 0 ;
8215   float result;
8216
8217   arg1 = (Dali::Vector4 *)jarg1;
8218   arg2 = (Dali::Vector3 *)jarg2;
8219   if (!arg2) {
8220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8221     return 0;
8222   }
8223   {
8224     try {
8225       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8226     } catch (std::out_of_range& e) {
8227       {
8228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8229       };
8230     } catch (std::exception& e) {
8231       {
8232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8233       };
8234     } catch (Dali::DaliException e) {
8235       {
8236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8237       };
8238     } catch (...) {
8239       {
8240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8241       };
8242     }
8243   }
8244
8245   jresult = result;
8246   return jresult;
8247 }
8248
8249
8250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8251   float jresult ;
8252   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8253   Dali::Vector4 *arg2 = 0 ;
8254   float result;
8255
8256   arg1 = (Dali::Vector4 *)jarg1;
8257   arg2 = (Dali::Vector4 *)jarg2;
8258   if (!arg2) {
8259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8260     return 0;
8261   }
8262   {
8263     try {
8264       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8265     } catch (std::out_of_range& e) {
8266       {
8267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8268       };
8269     } catch (std::exception& e) {
8270       {
8271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8272       };
8273     } catch (Dali::DaliException e) {
8274       {
8275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8276       };
8277     } catch (...) {
8278       {
8279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8280       };
8281     }
8282   }
8283
8284   jresult = result;
8285   return jresult;
8286 }
8287
8288
8289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8290   float jresult ;
8291   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8292   Dali::Vector4 *arg2 = 0 ;
8293   float result;
8294
8295   arg1 = (Dali::Vector4 *)jarg1;
8296   arg2 = (Dali::Vector4 *)jarg2;
8297   if (!arg2) {
8298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8299     return 0;
8300   }
8301   {
8302     try {
8303       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8304     } catch (std::out_of_range& e) {
8305       {
8306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8307       };
8308     } catch (std::exception& e) {
8309       {
8310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8311       };
8312     } catch (Dali::DaliException e) {
8313       {
8314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8315       };
8316     } catch (...) {
8317       {
8318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8319       };
8320     }
8321   }
8322
8323   jresult = result;
8324   return jresult;
8325 }
8326
8327
8328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8329   void * jresult ;
8330   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8331   Dali::Vector4 *arg2 = 0 ;
8332   Dali::Vector4 result;
8333
8334   arg1 = (Dali::Vector4 *)jarg1;
8335   arg2 = (Dali::Vector4 *)jarg2;
8336   if (!arg2) {
8337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8338     return 0;
8339   }
8340   {
8341     try {
8342       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8343     } catch (std::out_of_range& e) {
8344       {
8345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8346       };
8347     } catch (std::exception& e) {
8348       {
8349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8350       };
8351     } catch (Dali::DaliException e) {
8352       {
8353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8354       };
8355     } catch (...) {
8356       {
8357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8358       };
8359     }
8360   }
8361
8362   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8363   return jresult;
8364 }
8365
8366
8367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8368   float jresult ;
8369   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8370   float result;
8371
8372   arg1 = (Dali::Vector4 *)jarg1;
8373   {
8374     try {
8375       result = (float)((Dali::Vector4 const *)arg1)->Length();
8376     } catch (std::out_of_range& e) {
8377       {
8378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8379       };
8380     } catch (std::exception& e) {
8381       {
8382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8383       };
8384     } catch (Dali::DaliException e) {
8385       {
8386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8387       };
8388     } catch (...) {
8389       {
8390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8391       };
8392     }
8393   }
8394
8395   jresult = result;
8396   return jresult;
8397 }
8398
8399
8400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8401   float jresult ;
8402   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8403   float result;
8404
8405   arg1 = (Dali::Vector4 *)jarg1;
8406   {
8407     try {
8408       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8409     } catch (std::out_of_range& e) {
8410       {
8411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8412       };
8413     } catch (std::exception& e) {
8414       {
8415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8416       };
8417     } catch (Dali::DaliException e) {
8418       {
8419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8420       };
8421     } catch (...) {
8422       {
8423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8424       };
8425     }
8426   }
8427
8428   jresult = result;
8429   return jresult;
8430 }
8431
8432
8433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8434   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8435
8436   arg1 = (Dali::Vector4 *)jarg1;
8437   {
8438     try {
8439       (arg1)->Normalize();
8440     } catch (std::out_of_range& e) {
8441       {
8442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8443       };
8444     } catch (std::exception& e) {
8445       {
8446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8447       };
8448     } catch (Dali::DaliException e) {
8449       {
8450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8451       };
8452     } catch (...) {
8453       {
8454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8455       };
8456     }
8457   }
8458
8459 }
8460
8461
8462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8463   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8464   Dali::Vector4 *arg2 = 0 ;
8465   Dali::Vector4 *arg3 = 0 ;
8466
8467   arg1 = (Dali::Vector4 *)jarg1;
8468   arg2 = (Dali::Vector4 *)jarg2;
8469   if (!arg2) {
8470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8471     return ;
8472   }
8473   arg3 = (Dali::Vector4 *)jarg3;
8474   if (!arg3) {
8475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8476     return ;
8477   }
8478   {
8479     try {
8480       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8481     } catch (std::out_of_range& e) {
8482       {
8483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8484       };
8485     } catch (std::exception& e) {
8486       {
8487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8488       };
8489     } catch (Dali::DaliException e) {
8490       {
8491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8492       };
8493     } catch (...) {
8494       {
8495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8496       };
8497     }
8498   }
8499
8500 }
8501
8502
8503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8504   void * jresult ;
8505   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8506   float *result = 0 ;
8507
8508   arg1 = (Dali::Vector4 *)jarg1;
8509   {
8510     try {
8511       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8512     } catch (std::out_of_range& e) {
8513       {
8514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8515       };
8516     } catch (std::exception& e) {
8517       {
8518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8519       };
8520     } catch (Dali::DaliException e) {
8521       {
8522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8523       };
8524     } catch (...) {
8525       {
8526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8527       };
8528     }
8529   }
8530
8531   jresult = (void *)result;
8532   return jresult;
8533 }
8534
8535
8536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8537   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8538   float arg2 ;
8539
8540   arg1 = (Dali::Vector4 *)jarg1;
8541   arg2 = (float)jarg2;
8542   if (arg1) (arg1)->x = arg2;
8543 }
8544
8545
8546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8547   float jresult ;
8548   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8549   float result;
8550
8551   arg1 = (Dali::Vector4 *)jarg1;
8552   result = (float) ((arg1)->x);
8553   jresult = result;
8554   return jresult;
8555 }
8556
8557
8558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8559   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8560   float arg2 ;
8561
8562   arg1 = (Dali::Vector4 *)jarg1;
8563   arg2 = (float)jarg2;
8564   if (arg1) (arg1)->r = arg2;
8565 }
8566
8567
8568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8569   float jresult ;
8570   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8571   float result;
8572
8573   arg1 = (Dali::Vector4 *)jarg1;
8574   result = (float) ((arg1)->r);
8575   jresult = result;
8576   return jresult;
8577 }
8578
8579
8580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8581   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8582   float arg2 ;
8583
8584   arg1 = (Dali::Vector4 *)jarg1;
8585   arg2 = (float)jarg2;
8586   if (arg1) (arg1)->s = arg2;
8587 }
8588
8589
8590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8591   float jresult ;
8592   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8593   float result;
8594
8595   arg1 = (Dali::Vector4 *)jarg1;
8596   result = (float) ((arg1)->s);
8597   jresult = result;
8598   return jresult;
8599 }
8600
8601
8602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8603   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8604   float arg2 ;
8605
8606   arg1 = (Dali::Vector4 *)jarg1;
8607   arg2 = (float)jarg2;
8608   if (arg1) (arg1)->y = arg2;
8609 }
8610
8611
8612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8613   float jresult ;
8614   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8615   float result;
8616
8617   arg1 = (Dali::Vector4 *)jarg1;
8618   result = (float) ((arg1)->y);
8619   jresult = result;
8620   return jresult;
8621 }
8622
8623
8624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8625   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8626   float arg2 ;
8627
8628   arg1 = (Dali::Vector4 *)jarg1;
8629   arg2 = (float)jarg2;
8630   if (arg1) (arg1)->g = arg2;
8631 }
8632
8633
8634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8635   float jresult ;
8636   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8637   float result;
8638
8639   arg1 = (Dali::Vector4 *)jarg1;
8640   result = (float) ((arg1)->g);
8641   jresult = result;
8642   return jresult;
8643 }
8644
8645
8646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8647   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8648   float arg2 ;
8649
8650   arg1 = (Dali::Vector4 *)jarg1;
8651   arg2 = (float)jarg2;
8652   if (arg1) (arg1)->t = arg2;
8653 }
8654
8655
8656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8657   float jresult ;
8658   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8659   float result;
8660
8661   arg1 = (Dali::Vector4 *)jarg1;
8662   result = (float) ((arg1)->t);
8663   jresult = result;
8664   return jresult;
8665 }
8666
8667
8668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8669   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8670   float arg2 ;
8671
8672   arg1 = (Dali::Vector4 *)jarg1;
8673   arg2 = (float)jarg2;
8674   if (arg1) (arg1)->z = arg2;
8675 }
8676
8677
8678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8679   float jresult ;
8680   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8681   float result;
8682
8683   arg1 = (Dali::Vector4 *)jarg1;
8684   result = (float) ((arg1)->z);
8685   jresult = result;
8686   return jresult;
8687 }
8688
8689
8690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8691   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8692   float arg2 ;
8693
8694   arg1 = (Dali::Vector4 *)jarg1;
8695   arg2 = (float)jarg2;
8696   if (arg1) (arg1)->b = arg2;
8697 }
8698
8699
8700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8701   float jresult ;
8702   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8703   float result;
8704
8705   arg1 = (Dali::Vector4 *)jarg1;
8706   result = (float) ((arg1)->b);
8707   jresult = result;
8708   return jresult;
8709 }
8710
8711
8712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8713   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8714   float arg2 ;
8715
8716   arg1 = (Dali::Vector4 *)jarg1;
8717   arg2 = (float)jarg2;
8718   if (arg1) (arg1)->p = arg2;
8719 }
8720
8721
8722 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8723   float jresult ;
8724   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8725   float result;
8726
8727   arg1 = (Dali::Vector4 *)jarg1;
8728   result = (float) ((arg1)->p);
8729   jresult = result;
8730   return jresult;
8731 }
8732
8733
8734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8735   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8736   float arg2 ;
8737
8738   arg1 = (Dali::Vector4 *)jarg1;
8739   arg2 = (float)jarg2;
8740   if (arg1) (arg1)->w = arg2;
8741 }
8742
8743
8744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8745   float jresult ;
8746   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8747   float result;
8748
8749   arg1 = (Dali::Vector4 *)jarg1;
8750   result = (float) ((arg1)->w);
8751   jresult = result;
8752   return jresult;
8753 }
8754
8755
8756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8757   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8758   float arg2 ;
8759
8760   arg1 = (Dali::Vector4 *)jarg1;
8761   arg2 = (float)jarg2;
8762   if (arg1) (arg1)->a = arg2;
8763 }
8764
8765
8766 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8767   float jresult ;
8768   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8769   float result;
8770
8771   arg1 = (Dali::Vector4 *)jarg1;
8772   result = (float) ((arg1)->a);
8773   jresult = result;
8774   return jresult;
8775 }
8776
8777
8778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8779   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8780   float arg2 ;
8781
8782   arg1 = (Dali::Vector4 *)jarg1;
8783   arg2 = (float)jarg2;
8784   if (arg1) (arg1)->q = arg2;
8785 }
8786
8787
8788 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8789   float jresult ;
8790   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8791   float result;
8792
8793   arg1 = (Dali::Vector4 *)jarg1;
8794   result = (float) ((arg1)->q);
8795   jresult = result;
8796   return jresult;
8797 }
8798
8799
8800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8801   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8802
8803   arg1 = (Dali::Vector4 *)jarg1;
8804   {
8805     try {
8806       delete arg1;
8807     } catch (std::out_of_range& e) {
8808       {
8809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8810       };
8811     } catch (std::exception& e) {
8812       {
8813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8814       };
8815     } catch (Dali::DaliException e) {
8816       {
8817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8818       };
8819     } catch (...) {
8820       {
8821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8822       };
8823     }
8824   }
8825
8826 }
8827
8828
8829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8830   void * jresult ;
8831   Dali::Vector4 *arg1 = 0 ;
8832   Dali::Vector4 *arg2 = 0 ;
8833   Dali::Vector4 result;
8834
8835   arg1 = (Dali::Vector4 *)jarg1;
8836   if (!arg1) {
8837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8838     return 0;
8839   }
8840   arg2 = (Dali::Vector4 *)jarg2;
8841   if (!arg2) {
8842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8843     return 0;
8844   }
8845   {
8846     try {
8847       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8848     } catch (std::out_of_range& e) {
8849       {
8850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8851       };
8852     } catch (std::exception& e) {
8853       {
8854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8855       };
8856     } catch (Dali::DaliException e) {
8857       {
8858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8859       };
8860     } catch (...) {
8861       {
8862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8863       };
8864     }
8865   }
8866
8867   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8868   return jresult;
8869 }
8870
8871
8872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8873   void * jresult ;
8874   Dali::Vector4 *arg1 = 0 ;
8875   Dali::Vector4 *arg2 = 0 ;
8876   Dali::Vector4 result;
8877
8878   arg1 = (Dali::Vector4 *)jarg1;
8879   if (!arg1) {
8880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8881     return 0;
8882   }
8883   arg2 = (Dali::Vector4 *)jarg2;
8884   if (!arg2) {
8885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8886     return 0;
8887   }
8888   {
8889     try {
8890       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8891     } catch (std::out_of_range& e) {
8892       {
8893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8894       };
8895     } catch (std::exception& e) {
8896       {
8897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8898       };
8899     } catch (Dali::DaliException e) {
8900       {
8901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8902       };
8903     } catch (...) {
8904       {
8905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8906       };
8907     }
8908   }
8909
8910   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8911   return jresult;
8912 }
8913
8914
8915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8916   void * jresult ;
8917   Dali::Vector4 *arg1 = 0 ;
8918   float *arg2 = 0 ;
8919   float *arg3 = 0 ;
8920   float temp2 ;
8921   float temp3 ;
8922   Dali::Vector4 result;
8923
8924   arg1 = (Dali::Vector4 *)jarg1;
8925   if (!arg1) {
8926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8927     return 0;
8928   }
8929   temp2 = (float)jarg2;
8930   arg2 = &temp2;
8931   temp3 = (float)jarg3;
8932   arg3 = &temp3;
8933   {
8934     try {
8935       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8936     } catch (std::out_of_range& e) {
8937       {
8938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8939       };
8940     } catch (std::exception& e) {
8941       {
8942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8943       };
8944     } catch (Dali::DaliException e) {
8945       {
8946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8947       };
8948     } catch (...) {
8949       {
8950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8951       };
8952     }
8953   }
8954
8955   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8956   return jresult;
8957 }
8958
8959
8960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8961   void * jresult ;
8962   Dali::Uint16Pair *result = 0 ;
8963
8964   {
8965     try {
8966       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8967     } catch (std::out_of_range& e) {
8968       {
8969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8970       };
8971     } catch (std::exception& e) {
8972       {
8973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8974       };
8975     } catch (Dali::DaliException e) {
8976       {
8977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8978       };
8979     } catch (...) {
8980       {
8981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8982       };
8983     }
8984   }
8985
8986   jresult = (void *)result;
8987   return jresult;
8988 }
8989
8990
8991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8992   void * jresult ;
8993   uint32_t arg1 ;
8994   uint32_t arg2 ;
8995   Dali::Uint16Pair *result = 0 ;
8996
8997   arg1 = (uint32_t)jarg1;
8998   arg2 = (uint32_t)jarg2;
8999   {
9000     try {
9001       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
9002     } catch (std::out_of_range& e) {
9003       {
9004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9005       };
9006     } catch (std::exception& e) {
9007       {
9008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9009       };
9010     } catch (Dali::DaliException e) {
9011       {
9012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9013       };
9014     } catch (...) {
9015       {
9016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9017       };
9018     }
9019   }
9020
9021   jresult = (void *)result;
9022   return jresult;
9023 }
9024
9025
9026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9027   void * jresult ;
9028   Dali::Uint16Pair *arg1 = 0 ;
9029   Dali::Uint16Pair *result = 0 ;
9030
9031   arg1 = (Dali::Uint16Pair *)jarg1;
9032   if (!arg1) {
9033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9034     return 0;
9035   }
9036   {
9037     try {
9038       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9039     } catch (std::out_of_range& e) {
9040       {
9041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9042       };
9043     } catch (std::exception& e) {
9044       {
9045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9046       };
9047     } catch (Dali::DaliException e) {
9048       {
9049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9050       };
9051     } catch (...) {
9052       {
9053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9054       };
9055     }
9056   }
9057
9058   jresult = (void *)result;
9059   return jresult;
9060 }
9061
9062
9063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9064   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9065   uint16_t arg2 ;
9066
9067   arg1 = (Dali::Uint16Pair *)jarg1;
9068   arg2 = (uint16_t)jarg2;
9069   {
9070     try {
9071       (arg1)->SetWidth(arg2);
9072     } catch (std::out_of_range& e) {
9073       {
9074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9075       };
9076     } catch (std::exception& e) {
9077       {
9078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9079       };
9080     } catch (Dali::DaliException e) {
9081       {
9082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9083       };
9084     } catch (...) {
9085       {
9086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9087       };
9088     }
9089   }
9090
9091 }
9092
9093
9094 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9095   unsigned short jresult ;
9096   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9097   uint16_t result;
9098
9099   arg1 = (Dali::Uint16Pair *)jarg1;
9100   {
9101     try {
9102       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9103     } catch (std::out_of_range& e) {
9104       {
9105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9106       };
9107     } catch (std::exception& e) {
9108       {
9109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9110       };
9111     } catch (Dali::DaliException e) {
9112       {
9113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9114       };
9115     } catch (...) {
9116       {
9117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9118       };
9119     }
9120   }
9121
9122   jresult = result;
9123   return jresult;
9124 }
9125
9126
9127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9128   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9129   uint16_t arg2 ;
9130
9131   arg1 = (Dali::Uint16Pair *)jarg1;
9132   arg2 = (uint16_t)jarg2;
9133   {
9134     try {
9135       (arg1)->SetHeight(arg2);
9136     } catch (std::out_of_range& e) {
9137       {
9138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9139       };
9140     } catch (std::exception& e) {
9141       {
9142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9143       };
9144     } catch (Dali::DaliException e) {
9145       {
9146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9147       };
9148     } catch (...) {
9149       {
9150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9151       };
9152     }
9153   }
9154
9155 }
9156
9157
9158 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9159   unsigned short jresult ;
9160   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9161   uint16_t result;
9162
9163   arg1 = (Dali::Uint16Pair *)jarg1;
9164   {
9165     try {
9166       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9167     } catch (std::out_of_range& e) {
9168       {
9169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9170       };
9171     } catch (std::exception& e) {
9172       {
9173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9174       };
9175     } catch (Dali::DaliException e) {
9176       {
9177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9178       };
9179     } catch (...) {
9180       {
9181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9182       };
9183     }
9184   }
9185
9186   jresult = result;
9187   return jresult;
9188 }
9189
9190
9191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9192   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9193   uint16_t arg2 ;
9194
9195   arg1 = (Dali::Uint16Pair *)jarg1;
9196   arg2 = (uint16_t)jarg2;
9197   {
9198     try {
9199       (arg1)->SetX(arg2);
9200     } catch (std::out_of_range& e) {
9201       {
9202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9203       };
9204     } catch (std::exception& e) {
9205       {
9206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9207       };
9208     } catch (Dali::DaliException e) {
9209       {
9210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9211       };
9212     } catch (...) {
9213       {
9214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9215       };
9216     }
9217   }
9218
9219 }
9220
9221
9222 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9223   unsigned short jresult ;
9224   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9225   uint16_t result;
9226
9227   arg1 = (Dali::Uint16Pair *)jarg1;
9228   {
9229     try {
9230       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9231     } catch (std::out_of_range& e) {
9232       {
9233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9234       };
9235     } catch (std::exception& e) {
9236       {
9237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9238       };
9239     } catch (Dali::DaliException e) {
9240       {
9241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9242       };
9243     } catch (...) {
9244       {
9245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9246       };
9247     }
9248   }
9249
9250   jresult = result;
9251   return jresult;
9252 }
9253
9254
9255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9256   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9257   uint16_t arg2 ;
9258
9259   arg1 = (Dali::Uint16Pair *)jarg1;
9260   arg2 = (uint16_t)jarg2;
9261   {
9262     try {
9263       (arg1)->SetY(arg2);
9264     } catch (std::out_of_range& e) {
9265       {
9266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9267       };
9268     } catch (std::exception& e) {
9269       {
9270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9271       };
9272     } catch (Dali::DaliException e) {
9273       {
9274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9275       };
9276     } catch (...) {
9277       {
9278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9279       };
9280     }
9281   }
9282
9283 }
9284
9285
9286 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9287   unsigned short jresult ;
9288   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9289   uint16_t result;
9290
9291   arg1 = (Dali::Uint16Pair *)jarg1;
9292   {
9293     try {
9294       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9295     } catch (std::out_of_range& e) {
9296       {
9297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9298       };
9299     } catch (std::exception& e) {
9300       {
9301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9302       };
9303     } catch (Dali::DaliException e) {
9304       {
9305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9306       };
9307     } catch (...) {
9308       {
9309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9310       };
9311     }
9312   }
9313
9314   jresult = result;
9315   return jresult;
9316 }
9317
9318
9319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9320   void * jresult ;
9321   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9322   Dali::Uint16Pair *arg2 = 0 ;
9323   Dali::Uint16Pair *result = 0 ;
9324
9325   arg1 = (Dali::Uint16Pair *)jarg1;
9326   arg2 = (Dali::Uint16Pair *)jarg2;
9327   if (!arg2) {
9328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9329     return 0;
9330   }
9331   {
9332     try {
9333       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9334     } catch (std::out_of_range& e) {
9335       {
9336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9337       };
9338     } catch (std::exception& e) {
9339       {
9340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9341       };
9342     } catch (Dali::DaliException e) {
9343       {
9344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9345       };
9346     } catch (...) {
9347       {
9348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9349       };
9350     }
9351   }
9352
9353   jresult = (void *)result;
9354   return jresult;
9355 }
9356
9357
9358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9359   unsigned int jresult ;
9360   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9361   Dali::Uint16Pair *arg2 = 0 ;
9362   bool result;
9363
9364   arg1 = (Dali::Uint16Pair *)jarg1;
9365   arg2 = (Dali::Uint16Pair *)jarg2;
9366   if (!arg2) {
9367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9368     return 0;
9369   }
9370   {
9371     try {
9372       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9373     } catch (std::out_of_range& e) {
9374       {
9375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9376       };
9377     } catch (std::exception& e) {
9378       {
9379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9380       };
9381     } catch (Dali::DaliException e) {
9382       {
9383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9384       };
9385     } catch (...) {
9386       {
9387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9388       };
9389     }
9390   }
9391
9392   jresult = result;
9393   return jresult;
9394 }
9395
9396
9397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9398   unsigned int jresult ;
9399   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9400   Dali::Uint16Pair *arg2 = 0 ;
9401   bool result;
9402
9403   arg1 = (Dali::Uint16Pair *)jarg1;
9404   arg2 = (Dali::Uint16Pair *)jarg2;
9405   if (!arg2) {
9406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9407     return 0;
9408   }
9409   {
9410     try {
9411       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9412     } catch (std::out_of_range& e) {
9413       {
9414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9415       };
9416     } catch (std::exception& e) {
9417       {
9418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9419       };
9420     } catch (Dali::DaliException e) {
9421       {
9422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9423       };
9424     } catch (...) {
9425       {
9426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9427       };
9428     }
9429   }
9430
9431   jresult = result;
9432   return jresult;
9433 }
9434
9435
9436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9437   unsigned int jresult ;
9438   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9439   Dali::Uint16Pair *arg2 = 0 ;
9440   bool result;
9441
9442   arg1 = (Dali::Uint16Pair *)jarg1;
9443   arg2 = (Dali::Uint16Pair *)jarg2;
9444   if (!arg2) {
9445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9446     return 0;
9447   }
9448   {
9449     try {
9450       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9451     } catch (std::out_of_range& e) {
9452       {
9453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9454       };
9455     } catch (std::exception& e) {
9456       {
9457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9458       };
9459     } catch (Dali::DaliException e) {
9460       {
9461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9462       };
9463     } catch (...) {
9464       {
9465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9466       };
9467     }
9468   }
9469
9470   jresult = result;
9471   return jresult;
9472 }
9473
9474
9475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9476   unsigned int jresult ;
9477   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9478   Dali::Uint16Pair *arg2 = 0 ;
9479   bool result;
9480
9481   arg1 = (Dali::Uint16Pair *)jarg1;
9482   arg2 = (Dali::Uint16Pair *)jarg2;
9483   if (!arg2) {
9484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9485     return 0;
9486   }
9487   {
9488     try {
9489       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9490     } catch (std::out_of_range& e) {
9491       {
9492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9493       };
9494     } catch (std::exception& e) {
9495       {
9496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9497       };
9498     } catch (Dali::DaliException e) {
9499       {
9500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9501       };
9502     } catch (...) {
9503       {
9504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9505       };
9506     }
9507   }
9508
9509   jresult = result;
9510   return jresult;
9511 }
9512
9513
9514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9515   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9516
9517   arg1 = (Dali::Uint16Pair *)jarg1;
9518   {
9519     try {
9520       delete arg1;
9521     } catch (std::out_of_range& e) {
9522       {
9523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9524       };
9525     } catch (std::exception& e) {
9526       {
9527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9528       };
9529     } catch (Dali::DaliException e) {
9530       {
9531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9532       };
9533     } catch (...) {
9534       {
9535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9536       };
9537     }
9538   }
9539
9540 }
9541
9542
9543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9544   void * jresult ;
9545   Dali::Degree *result = 0 ;
9546
9547   {
9548     try {
9549       result = (Dali::Degree *)new Dali::Degree();
9550     } catch (std::out_of_range& e) {
9551       {
9552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9553       };
9554     } catch (std::exception& e) {
9555       {
9556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9557       };
9558     } catch (Dali::DaliException e) {
9559       {
9560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9561       };
9562     } catch (...) {
9563       {
9564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9565       };
9566     }
9567   }
9568
9569   jresult = (void *)result;
9570   return jresult;
9571 }
9572
9573
9574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9575   void * jresult ;
9576   float arg1 ;
9577   Dali::Degree *result = 0 ;
9578
9579   arg1 = (float)jarg1;
9580   {
9581     try {
9582       result = (Dali::Degree *)new Dali::Degree(arg1);
9583     } catch (std::out_of_range& e) {
9584       {
9585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9586       };
9587     } catch (std::exception& e) {
9588       {
9589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9590       };
9591     } catch (Dali::DaliException e) {
9592       {
9593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9594       };
9595     } catch (...) {
9596       {
9597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9598       };
9599     }
9600   }
9601
9602   jresult = (void *)result;
9603   return jresult;
9604 }
9605
9606
9607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9608   void * jresult ;
9609   Dali::Radian arg1 ;
9610   Dali::Radian *argp1 ;
9611   Dali::Degree *result = 0 ;
9612
9613   argp1 = (Dali::Radian *)jarg1;
9614   if (!argp1) {
9615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9616     return 0;
9617   }
9618   arg1 = *argp1;
9619   {
9620     try {
9621       result = (Dali::Degree *)new Dali::Degree(arg1);
9622     } catch (std::out_of_range& e) {
9623       {
9624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9625       };
9626     } catch (std::exception& e) {
9627       {
9628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9629       };
9630     } catch (Dali::DaliException e) {
9631       {
9632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9633       };
9634     } catch (...) {
9635       {
9636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9637       };
9638     }
9639   }
9640
9641   jresult = (void *)result;
9642   return jresult;
9643 }
9644
9645
9646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9647   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9648   float arg2 ;
9649
9650   arg1 = (Dali::Degree *)jarg1;
9651   arg2 = (float)jarg2;
9652   if (arg1) (arg1)->degree = arg2;
9653 }
9654
9655
9656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9657   float jresult ;
9658   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9659   float result;
9660
9661   arg1 = (Dali::Degree *)jarg1;
9662   result = (float) ((arg1)->degree);
9663   jresult = result;
9664   return jresult;
9665 }
9666
9667
9668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9669   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9670
9671   arg1 = (Dali::Degree *)jarg1;
9672   {
9673     try {
9674       delete arg1;
9675     } catch (std::out_of_range& e) {
9676       {
9677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9678       };
9679     } catch (std::exception& e) {
9680       {
9681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9682       };
9683     } catch (Dali::DaliException e) {
9684       {
9685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9686       };
9687     } catch (...) {
9688       {
9689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9690       };
9691     }
9692   }
9693
9694 }
9695
9696
9697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9698   void * jresult ;
9699   Dali::Radian *result = 0 ;
9700
9701   result = (Dali::Radian *)&Dali::ANGLE_360;
9702   jresult = (void *)result;
9703   return jresult;
9704 }
9705
9706
9707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9708   void * jresult ;
9709   Dali::Radian *result = 0 ;
9710
9711   result = (Dali::Radian *)&Dali::ANGLE_315;
9712   jresult = (void *)result;
9713   return jresult;
9714 }
9715
9716
9717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9718   void * jresult ;
9719   Dali::Radian *result = 0 ;
9720
9721   result = (Dali::Radian *)&Dali::ANGLE_270;
9722   jresult = (void *)result;
9723   return jresult;
9724 }
9725
9726
9727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9728   void * jresult ;
9729   Dali::Radian *result = 0 ;
9730
9731   result = (Dali::Radian *)&Dali::ANGLE_225;
9732   jresult = (void *)result;
9733   return jresult;
9734 }
9735
9736
9737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9738   void * jresult ;
9739   Dali::Radian *result = 0 ;
9740
9741   result = (Dali::Radian *)&Dali::ANGLE_180;
9742   jresult = (void *)result;
9743   return jresult;
9744 }
9745
9746
9747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9748   void * jresult ;
9749   Dali::Radian *result = 0 ;
9750
9751   result = (Dali::Radian *)&Dali::ANGLE_135;
9752   jresult = (void *)result;
9753   return jresult;
9754 }
9755
9756
9757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9758   void * jresult ;
9759   Dali::Radian *result = 0 ;
9760
9761   result = (Dali::Radian *)&Dali::ANGLE_120;
9762   jresult = (void *)result;
9763   return jresult;
9764 }
9765
9766
9767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9768   void * jresult ;
9769   Dali::Radian *result = 0 ;
9770
9771   result = (Dali::Radian *)&Dali::ANGLE_90;
9772   jresult = (void *)result;
9773   return jresult;
9774 }
9775
9776
9777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9778   void * jresult ;
9779   Dali::Radian *result = 0 ;
9780
9781   result = (Dali::Radian *)&Dali::ANGLE_60;
9782   jresult = (void *)result;
9783   return jresult;
9784 }
9785
9786
9787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9788   void * jresult ;
9789   Dali::Radian *result = 0 ;
9790
9791   result = (Dali::Radian *)&Dali::ANGLE_45;
9792   jresult = (void *)result;
9793   return jresult;
9794 }
9795
9796
9797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9798   void * jresult ;
9799   Dali::Radian *result = 0 ;
9800
9801   result = (Dali::Radian *)&Dali::ANGLE_30;
9802   jresult = (void *)result;
9803   return jresult;
9804 }
9805
9806
9807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9808   void * jresult ;
9809   Dali::Radian *result = 0 ;
9810
9811   result = (Dali::Radian *)&Dali::ANGLE_0;
9812   jresult = (void *)result;
9813   return jresult;
9814 }
9815
9816
9817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9818   unsigned int jresult ;
9819   Dali::Degree *arg1 = 0 ;
9820   Dali::Degree *arg2 = 0 ;
9821   bool result;
9822
9823   arg1 = (Dali::Degree *)jarg1;
9824   if (!arg1) {
9825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9826     return 0;
9827   }
9828   arg2 = (Dali::Degree *)jarg2;
9829   if (!arg2) {
9830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9831     return 0;
9832   }
9833   {
9834     try {
9835       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9836     } catch (std::out_of_range& e) {
9837       {
9838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9839       };
9840     } catch (std::exception& e) {
9841       {
9842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9843       };
9844     } catch (Dali::DaliException e) {
9845       {
9846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9847       };
9848     } catch (...) {
9849       {
9850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9851       };
9852     }
9853   }
9854
9855   jresult = result;
9856   return jresult;
9857 }
9858
9859
9860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9861   unsigned int jresult ;
9862   Dali::Degree *arg1 = 0 ;
9863   Dali::Degree *arg2 = 0 ;
9864   bool result;
9865
9866   arg1 = (Dali::Degree *)jarg1;
9867   if (!arg1) {
9868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9869     return 0;
9870   }
9871   arg2 = (Dali::Degree *)jarg2;
9872   if (!arg2) {
9873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9874     return 0;
9875   }
9876   {
9877     try {
9878       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9879     } catch (std::out_of_range& e) {
9880       {
9881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9882       };
9883     } catch (std::exception& e) {
9884       {
9885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9886       };
9887     } catch (Dali::DaliException e) {
9888       {
9889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9890       };
9891     } catch (...) {
9892       {
9893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9894       };
9895     }
9896   }
9897
9898   jresult = result;
9899   return jresult;
9900 }
9901
9902
9903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9904   void * jresult ;
9905   Dali::Degree arg1 ;
9906   float arg2 ;
9907   float arg3 ;
9908   Dali::Degree *argp1 ;
9909   Dali::Degree result;
9910
9911   argp1 = (Dali::Degree *)jarg1;
9912   if (!argp1) {
9913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9914     return 0;
9915   }
9916   arg1 = *argp1;
9917   arg2 = (float)jarg2;
9918   arg3 = (float)jarg3;
9919   {
9920     try {
9921       result = Dali::Clamp(arg1,arg2,arg3);
9922     } catch (std::out_of_range& e) {
9923       {
9924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9925       };
9926     } catch (std::exception& e) {
9927       {
9928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9929       };
9930     } catch (Dali::DaliException e) {
9931       {
9932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9933       };
9934     } catch (...) {
9935       {
9936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9937       };
9938     }
9939   }
9940
9941   jresult = new Dali::Degree((const Dali::Degree &)result);
9942   return jresult;
9943 }
9944
9945
9946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9947   void * jresult ;
9948   Dali::Radian *result = 0 ;
9949
9950   {
9951     try {
9952       result = (Dali::Radian *)new Dali::Radian();
9953     } catch (std::out_of_range& e) {
9954       {
9955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9956       };
9957     } catch (std::exception& e) {
9958       {
9959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9960       };
9961     } catch (Dali::DaliException e) {
9962       {
9963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9964       };
9965     } catch (...) {
9966       {
9967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9968       };
9969     }
9970   }
9971
9972   jresult = (void *)result;
9973   return jresult;
9974 }
9975
9976
9977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9978   void * jresult ;
9979   float arg1 ;
9980   Dali::Radian *result = 0 ;
9981
9982   arg1 = (float)jarg1;
9983   {
9984     try {
9985       result = (Dali::Radian *)new Dali::Radian(arg1);
9986     } catch (std::out_of_range& e) {
9987       {
9988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9989       };
9990     } catch (std::exception& e) {
9991       {
9992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9993       };
9994     } catch (Dali::DaliException e) {
9995       {
9996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9997       };
9998     } catch (...) {
9999       {
10000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10001       };
10002     }
10003   }
10004
10005   jresult = (void *)result;
10006   return jresult;
10007 }
10008
10009
10010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10011   void * jresult ;
10012   Dali::Degree arg1 ;
10013   Dali::Degree *argp1 ;
10014   Dali::Radian *result = 0 ;
10015
10016   argp1 = (Dali::Degree *)jarg1;
10017   if (!argp1) {
10018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10019     return 0;
10020   }
10021   arg1 = *argp1;
10022   {
10023     try {
10024       result = (Dali::Radian *)new Dali::Radian(arg1);
10025     } catch (std::out_of_range& e) {
10026       {
10027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10028       };
10029     } catch (std::exception& e) {
10030       {
10031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10032       };
10033     } catch (Dali::DaliException e) {
10034       {
10035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10036       };
10037     } catch (...) {
10038       {
10039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10040       };
10041     }
10042   }
10043
10044   jresult = (void *)result;
10045   return jresult;
10046 }
10047
10048
10049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10050   void * jresult ;
10051   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10052   float arg2 ;
10053   Dali::Radian *result = 0 ;
10054
10055   arg1 = (Dali::Radian *)jarg1;
10056   arg2 = (float)jarg2;
10057   {
10058     try {
10059       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10060     } catch (std::out_of_range& e) {
10061       {
10062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10063       };
10064     } catch (std::exception& e) {
10065       {
10066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10067       };
10068     } catch (Dali::DaliException e) {
10069       {
10070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10071       };
10072     } catch (...) {
10073       {
10074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10075       };
10076     }
10077   }
10078
10079   jresult = (void *)result;
10080   return jresult;
10081 }
10082
10083
10084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10085   void * jresult ;
10086   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10087   Dali::Degree arg2 ;
10088   Dali::Degree *argp2 ;
10089   Dali::Radian *result = 0 ;
10090
10091   arg1 = (Dali::Radian *)jarg1;
10092   argp2 = (Dali::Degree *)jarg2;
10093   if (!argp2) {
10094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10095     return 0;
10096   }
10097   arg2 = *argp2;
10098   {
10099     try {
10100       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10101     } catch (std::out_of_range& e) {
10102       {
10103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10104       };
10105     } catch (std::exception& e) {
10106       {
10107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10108       };
10109     } catch (Dali::DaliException e) {
10110       {
10111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10112       };
10113     } catch (...) {
10114       {
10115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10116       };
10117     }
10118   }
10119
10120   jresult = (void *)result;
10121   return jresult;
10122 }
10123
10124
10125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10126   float jresult ;
10127   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10128   float result;
10129
10130   arg1 = (Dali::Radian *)jarg1;
10131   {
10132     try {
10133       result = (float)((Dali::Radian const *)arg1)->operator float();
10134     } catch (std::out_of_range& e) {
10135       {
10136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10137       };
10138     } catch (std::exception& e) {
10139       {
10140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10141       };
10142     } catch (Dali::DaliException e) {
10143       {
10144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10145       };
10146     } catch (...) {
10147       {
10148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10149       };
10150     }
10151   }
10152
10153   jresult = result;
10154   return jresult;
10155 }
10156
10157
10158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10159   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10160   float arg2 ;
10161
10162   arg1 = (Dali::Radian *)jarg1;
10163   arg2 = (float)jarg2;
10164   if (arg1) (arg1)->radian = arg2;
10165 }
10166
10167
10168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10169   float jresult ;
10170   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10171   float result;
10172
10173   arg1 = (Dali::Radian *)jarg1;
10174   result = (float) ((arg1)->radian);
10175   jresult = result;
10176   return jresult;
10177 }
10178
10179
10180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10181   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10182
10183   arg1 = (Dali::Radian *)jarg1;
10184   {
10185     try {
10186       delete arg1;
10187     } catch (std::out_of_range& e) {
10188       {
10189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10190       };
10191     } catch (std::exception& e) {
10192       {
10193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10194       };
10195     } catch (Dali::DaliException e) {
10196       {
10197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10198       };
10199     } catch (...) {
10200       {
10201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10202       };
10203     }
10204   }
10205
10206 }
10207
10208
10209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10210   unsigned int jresult ;
10211   Dali::Radian arg1 ;
10212   Dali::Radian arg2 ;
10213   Dali::Radian *argp1 ;
10214   Dali::Radian *argp2 ;
10215   bool result;
10216
10217   argp1 = (Dali::Radian *)jarg1;
10218   if (!argp1) {
10219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10220     return 0;
10221   }
10222   arg1 = *argp1;
10223   argp2 = (Dali::Radian *)jarg2;
10224   if (!argp2) {
10225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10226     return 0;
10227   }
10228   arg2 = *argp2;
10229   {
10230     try {
10231       result = (bool)Dali::operator ==(arg1,arg2);
10232     } catch (std::out_of_range& e) {
10233       {
10234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10235       };
10236     } catch (std::exception& e) {
10237       {
10238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10239       };
10240     } catch (Dali::DaliException e) {
10241       {
10242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10243       };
10244     } catch (...) {
10245       {
10246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10247       };
10248     }
10249   }
10250
10251   jresult = result;
10252   return jresult;
10253 }
10254
10255
10256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10257   unsigned int jresult ;
10258   Dali::Radian arg1 ;
10259   Dali::Radian arg2 ;
10260   Dali::Radian *argp1 ;
10261   Dali::Radian *argp2 ;
10262   bool result;
10263
10264   argp1 = (Dali::Radian *)jarg1;
10265   if (!argp1) {
10266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10267     return 0;
10268   }
10269   arg1 = *argp1;
10270   argp2 = (Dali::Radian *)jarg2;
10271   if (!argp2) {
10272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10273     return 0;
10274   }
10275   arg2 = *argp2;
10276   {
10277     try {
10278       result = (bool)Dali::operator !=(arg1,arg2);
10279     } catch (std::out_of_range& e) {
10280       {
10281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10282       };
10283     } catch (std::exception& e) {
10284       {
10285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10286       };
10287     } catch (Dali::DaliException e) {
10288       {
10289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10290       };
10291     } catch (...) {
10292       {
10293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10294       };
10295     }
10296   }
10297
10298   jresult = result;
10299   return jresult;
10300 }
10301
10302
10303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10304   unsigned int jresult ;
10305   Dali::Radian arg1 ;
10306   Dali::Degree arg2 ;
10307   Dali::Radian *argp1 ;
10308   Dali::Degree *argp2 ;
10309   bool result;
10310
10311   argp1 = (Dali::Radian *)jarg1;
10312   if (!argp1) {
10313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10314     return 0;
10315   }
10316   arg1 = *argp1;
10317   argp2 = (Dali::Degree *)jarg2;
10318   if (!argp2) {
10319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10320     return 0;
10321   }
10322   arg2 = *argp2;
10323   {
10324     try {
10325       result = (bool)Dali::operator ==(arg1,arg2);
10326     } catch (std::out_of_range& e) {
10327       {
10328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10329       };
10330     } catch (std::exception& e) {
10331       {
10332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10333       };
10334     } catch (Dali::DaliException e) {
10335       {
10336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10337       };
10338     } catch (...) {
10339       {
10340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10341       };
10342     }
10343   }
10344
10345   jresult = result;
10346   return jresult;
10347 }
10348
10349
10350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10351   unsigned int jresult ;
10352   Dali::Radian arg1 ;
10353   Dali::Degree arg2 ;
10354   Dali::Radian *argp1 ;
10355   Dali::Degree *argp2 ;
10356   bool result;
10357
10358   argp1 = (Dali::Radian *)jarg1;
10359   if (!argp1) {
10360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10361     return 0;
10362   }
10363   arg1 = *argp1;
10364   argp2 = (Dali::Degree *)jarg2;
10365   if (!argp2) {
10366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10367     return 0;
10368   }
10369   arg2 = *argp2;
10370   {
10371     try {
10372       result = (bool)Dali::operator !=(arg1,arg2);
10373     } catch (std::out_of_range& e) {
10374       {
10375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10376       };
10377     } catch (std::exception& e) {
10378       {
10379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10380       };
10381     } catch (Dali::DaliException e) {
10382       {
10383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10384       };
10385     } catch (...) {
10386       {
10387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10388       };
10389     }
10390   }
10391
10392   jresult = result;
10393   return jresult;
10394 }
10395
10396
10397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10398   unsigned int jresult ;
10399   Dali::Degree arg1 ;
10400   Dali::Radian arg2 ;
10401   Dali::Degree *argp1 ;
10402   Dali::Radian *argp2 ;
10403   bool result;
10404
10405   argp1 = (Dali::Degree *)jarg1;
10406   if (!argp1) {
10407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10408     return 0;
10409   }
10410   arg1 = *argp1;
10411   argp2 = (Dali::Radian *)jarg2;
10412   if (!argp2) {
10413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10414     return 0;
10415   }
10416   arg2 = *argp2;
10417   {
10418     try {
10419       result = (bool)Dali::operator ==(arg1,arg2);
10420     } catch (std::out_of_range& e) {
10421       {
10422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10423       };
10424     } catch (std::exception& e) {
10425       {
10426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10427       };
10428     } catch (Dali::DaliException e) {
10429       {
10430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10431       };
10432     } catch (...) {
10433       {
10434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10435       };
10436     }
10437   }
10438
10439   jresult = result;
10440   return jresult;
10441 }
10442
10443
10444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10445   unsigned int jresult ;
10446   Dali::Degree arg1 ;
10447   Dali::Radian arg2 ;
10448   Dali::Degree *argp1 ;
10449   Dali::Radian *argp2 ;
10450   bool result;
10451
10452   argp1 = (Dali::Degree *)jarg1;
10453   if (!argp1) {
10454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10455     return 0;
10456   }
10457   arg1 = *argp1;
10458   argp2 = (Dali::Radian *)jarg2;
10459   if (!argp2) {
10460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10461     return 0;
10462   }
10463   arg2 = *argp2;
10464   {
10465     try {
10466       result = (bool)Dali::operator !=(arg1,arg2);
10467     } catch (std::out_of_range& e) {
10468       {
10469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10470       };
10471     } catch (std::exception& e) {
10472       {
10473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10474       };
10475     } catch (Dali::DaliException e) {
10476       {
10477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10478       };
10479     } catch (...) {
10480       {
10481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10482       };
10483     }
10484   }
10485
10486   jresult = result;
10487   return jresult;
10488 }
10489
10490
10491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10492   unsigned int jresult ;
10493   Dali::Radian arg1 ;
10494   Dali::Radian arg2 ;
10495   Dali::Radian *argp1 ;
10496   Dali::Radian *argp2 ;
10497   bool result;
10498
10499   argp1 = (Dali::Radian *)jarg1;
10500   if (!argp1) {
10501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10502     return 0;
10503   }
10504   arg1 = *argp1;
10505   argp2 = (Dali::Radian *)jarg2;
10506   if (!argp2) {
10507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10508     return 0;
10509   }
10510   arg2 = *argp2;
10511   {
10512     try {
10513       result = (bool)Dali::operator >(arg1,arg2);
10514     } catch (std::out_of_range& e) {
10515       {
10516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10517       };
10518     } catch (std::exception& e) {
10519       {
10520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10521       };
10522     } catch (Dali::DaliException e) {
10523       {
10524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10525       };
10526     } catch (...) {
10527       {
10528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10529       };
10530     }
10531   }
10532
10533   jresult = result;
10534   return jresult;
10535 }
10536
10537
10538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10539   unsigned int jresult ;
10540   Dali::Radian arg1 ;
10541   Dali::Degree arg2 ;
10542   Dali::Radian *argp1 ;
10543   Dali::Degree *argp2 ;
10544   bool result;
10545
10546   argp1 = (Dali::Radian *)jarg1;
10547   if (!argp1) {
10548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10549     return 0;
10550   }
10551   arg1 = *argp1;
10552   argp2 = (Dali::Degree *)jarg2;
10553   if (!argp2) {
10554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10555     return 0;
10556   }
10557   arg2 = *argp2;
10558   {
10559     try {
10560       result = (bool)Dali::operator >(arg1,arg2);
10561     } catch (std::out_of_range& e) {
10562       {
10563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10564       };
10565     } catch (std::exception& e) {
10566       {
10567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10568       };
10569     } catch (Dali::DaliException e) {
10570       {
10571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10572       };
10573     } catch (...) {
10574       {
10575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10576       };
10577     }
10578   }
10579
10580   jresult = result;
10581   return jresult;
10582 }
10583
10584
10585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10586   unsigned int jresult ;
10587   Dali::Degree arg1 ;
10588   Dali::Radian arg2 ;
10589   Dali::Degree *argp1 ;
10590   Dali::Radian *argp2 ;
10591   bool result;
10592
10593   argp1 = (Dali::Degree *)jarg1;
10594   if (!argp1) {
10595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10596     return 0;
10597   }
10598   arg1 = *argp1;
10599   argp2 = (Dali::Radian *)jarg2;
10600   if (!argp2) {
10601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10602     return 0;
10603   }
10604   arg2 = *argp2;
10605   {
10606     try {
10607       result = (bool)Dali::operator >(arg1,arg2);
10608     } catch (std::out_of_range& e) {
10609       {
10610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10611       };
10612     } catch (std::exception& e) {
10613       {
10614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10615       };
10616     } catch (Dali::DaliException e) {
10617       {
10618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10619       };
10620     } catch (...) {
10621       {
10622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10623       };
10624     }
10625   }
10626
10627   jresult = result;
10628   return jresult;
10629 }
10630
10631
10632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10633   unsigned int jresult ;
10634   Dali::Radian arg1 ;
10635   Dali::Radian arg2 ;
10636   Dali::Radian *argp1 ;
10637   Dali::Radian *argp2 ;
10638   bool result;
10639
10640   argp1 = (Dali::Radian *)jarg1;
10641   if (!argp1) {
10642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10643     return 0;
10644   }
10645   arg1 = *argp1;
10646   argp2 = (Dali::Radian *)jarg2;
10647   if (!argp2) {
10648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10649     return 0;
10650   }
10651   arg2 = *argp2;
10652   {
10653     try {
10654       result = (bool)Dali::operator <(arg1,arg2);
10655     } catch (std::out_of_range& e) {
10656       {
10657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10658       };
10659     } catch (std::exception& e) {
10660       {
10661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10662       };
10663     } catch (Dali::DaliException e) {
10664       {
10665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10666       };
10667     } catch (...) {
10668       {
10669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10670       };
10671     }
10672   }
10673
10674   jresult = result;
10675   return jresult;
10676 }
10677
10678
10679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10680   unsigned int jresult ;
10681   Dali::Radian arg1 ;
10682   Dali::Degree arg2 ;
10683   Dali::Radian *argp1 ;
10684   Dali::Degree *argp2 ;
10685   bool result;
10686
10687   argp1 = (Dali::Radian *)jarg1;
10688   if (!argp1) {
10689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10690     return 0;
10691   }
10692   arg1 = *argp1;
10693   argp2 = (Dali::Degree *)jarg2;
10694   if (!argp2) {
10695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10696     return 0;
10697   }
10698   arg2 = *argp2;
10699   {
10700     try {
10701       result = (bool)Dali::operator <(arg1,arg2);
10702     } catch (std::out_of_range& e) {
10703       {
10704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10705       };
10706     } catch (std::exception& e) {
10707       {
10708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10709       };
10710     } catch (Dali::DaliException e) {
10711       {
10712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10713       };
10714     } catch (...) {
10715       {
10716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10717       };
10718     }
10719   }
10720
10721   jresult = result;
10722   return jresult;
10723 }
10724
10725
10726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10727   unsigned int jresult ;
10728   Dali::Degree arg1 ;
10729   Dali::Radian arg2 ;
10730   Dali::Degree *argp1 ;
10731   Dali::Radian *argp2 ;
10732   bool result;
10733
10734   argp1 = (Dali::Degree *)jarg1;
10735   if (!argp1) {
10736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10737     return 0;
10738   }
10739   arg1 = *argp1;
10740   argp2 = (Dali::Radian *)jarg2;
10741   if (!argp2) {
10742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10743     return 0;
10744   }
10745   arg2 = *argp2;
10746   {
10747     try {
10748       result = (bool)Dali::operator <(arg1,arg2);
10749     } catch (std::out_of_range& e) {
10750       {
10751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10752       };
10753     } catch (std::exception& e) {
10754       {
10755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10756       };
10757     } catch (Dali::DaliException e) {
10758       {
10759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10760       };
10761     } catch (...) {
10762       {
10763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10764       };
10765     }
10766   }
10767
10768   jresult = result;
10769   return jresult;
10770 }
10771
10772
10773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10774   void * jresult ;
10775   Dali::Radian arg1 ;
10776   float arg2 ;
10777   Dali::Radian *argp1 ;
10778   Dali::Radian result;
10779
10780   argp1 = (Dali::Radian *)jarg1;
10781   if (!argp1) {
10782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10783     return 0;
10784   }
10785   arg1 = *argp1;
10786   arg2 = (float)jarg2;
10787   {
10788     try {
10789       result = Dali::operator *(arg1,arg2);
10790     } catch (std::out_of_range& e) {
10791       {
10792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10793       };
10794     } catch (std::exception& e) {
10795       {
10796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10797       };
10798     } catch (Dali::DaliException e) {
10799       {
10800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10801       };
10802     } catch (...) {
10803       {
10804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10805       };
10806     }
10807   }
10808
10809   jresult = new Dali::Radian((const Dali::Radian &)result);
10810   return jresult;
10811 }
10812
10813
10814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10815   void * jresult ;
10816   Dali::Radian arg1 ;
10817   Dali::Radian *argp1 ;
10818   Dali::Radian result;
10819
10820   argp1 = (Dali::Radian *)jarg1;
10821   if (!argp1) {
10822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10823     return 0;
10824   }
10825   arg1 = *argp1;
10826   {
10827     try {
10828       result = Dali::operator -(arg1);
10829     } catch (std::out_of_range& e) {
10830       {
10831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10832       };
10833     } catch (std::exception& e) {
10834       {
10835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10836       };
10837     } catch (Dali::DaliException e) {
10838       {
10839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10840       };
10841     } catch (...) {
10842       {
10843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10844       };
10845     }
10846   }
10847
10848   jresult = new Dali::Radian((const Dali::Radian &)result);
10849   return jresult;
10850 }
10851
10852
10853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10854   void * jresult ;
10855   Dali::Radian arg1 ;
10856   float arg2 ;
10857   float arg3 ;
10858   Dali::Radian *argp1 ;
10859   Dali::Radian result;
10860
10861   argp1 = (Dali::Radian *)jarg1;
10862   if (!argp1) {
10863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10864     return 0;
10865   }
10866   arg1 = *argp1;
10867   arg2 = (float)jarg2;
10868   arg3 = (float)jarg3;
10869   {
10870     try {
10871       result = Dali::Clamp(arg1,arg2,arg3);
10872     } catch (std::out_of_range& e) {
10873       {
10874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10875       };
10876     } catch (std::exception& e) {
10877       {
10878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10879       };
10880     } catch (Dali::DaliException e) {
10881       {
10882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10883       };
10884     } catch (...) {
10885       {
10886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10887       };
10888     }
10889   }
10890
10891   jresult = new Dali::Radian((const Dali::Radian &)result);
10892   return jresult;
10893 }
10894
10895
10896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10897   void * jresult ;
10898   Dali::Quaternion *result = 0 ;
10899
10900   {
10901     try {
10902       result = (Dali::Quaternion *)new Dali::Quaternion();
10903     } catch (std::out_of_range& e) {
10904       {
10905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10906       };
10907     } catch (std::exception& e) {
10908       {
10909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10910       };
10911     } catch (Dali::DaliException e) {
10912       {
10913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10914       };
10915     } catch (...) {
10916       {
10917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10918       };
10919     }
10920   }
10921
10922   jresult = (void *)result;
10923   return jresult;
10924 }
10925
10926
10927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10928   void * jresult ;
10929   Dali::Radian arg1 ;
10930   Dali::Vector3 *arg2 = 0 ;
10931   Dali::Radian *argp1 ;
10932   Dali::Quaternion *result = 0 ;
10933
10934   argp1 = (Dali::Radian *)jarg1;
10935   if (!argp1) {
10936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10937     return 0;
10938   }
10939   arg1 = *argp1;
10940   arg2 = (Dali::Vector3 *)jarg2;
10941   if (!arg2) {
10942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10943     return 0;
10944   }
10945   {
10946     try {
10947       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10948     } catch (std::out_of_range& e) {
10949       {
10950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10951       };
10952     } catch (std::exception& e) {
10953       {
10954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10955       };
10956     } catch (Dali::DaliException e) {
10957       {
10958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10959       };
10960     } catch (...) {
10961       {
10962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10963       };
10964     }
10965   }
10966
10967   jresult = (void *)result;
10968   return jresult;
10969 }
10970
10971
10972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10973   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10974
10975   arg1 = (Dali::Quaternion *)jarg1;
10976   {
10977     try {
10978       delete arg1;
10979     } catch (std::out_of_range& e) {
10980       {
10981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10982       };
10983     } catch (std::exception& e) {
10984       {
10985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10986       };
10987     } catch (Dali::DaliException e) {
10988       {
10989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10990       };
10991     } catch (...) {
10992       {
10993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10994       };
10995     }
10996   }
10997
10998 }
10999
11000
11001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
11002   void * jresult ;
11003   Dali::Quaternion *result = 0 ;
11004
11005   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11006   jresult = (void *)result;
11007   return jresult;
11008 }
11009
11010
11011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11012   unsigned int jresult ;
11013   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11014   bool result;
11015
11016   arg1 = (Dali::Quaternion *)jarg1;
11017   {
11018     try {
11019       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11020     } catch (std::out_of_range& e) {
11021       {
11022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11023       };
11024     } catch (std::exception& e) {
11025       {
11026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11027       };
11028     } catch (Dali::DaliException e) {
11029       {
11030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11031       };
11032     } catch (...) {
11033       {
11034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11035       };
11036     }
11037   }
11038
11039   jresult = result;
11040   return jresult;
11041 }
11042
11043
11044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11045   unsigned int jresult ;
11046   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11047   Dali::Vector3 *arg2 = 0 ;
11048   Dali::Radian *arg3 = 0 ;
11049   bool result;
11050
11051   arg1 = (Dali::Quaternion *)jarg1;
11052   arg2 = (Dali::Vector3 *)jarg2;
11053   if (!arg2) {
11054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11055     return 0;
11056   }
11057   arg3 = (Dali::Radian *)jarg3;
11058   if (!arg3) {
11059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11060     return 0;
11061   }
11062   {
11063     try {
11064       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11065     } catch (std::out_of_range& e) {
11066       {
11067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11068       };
11069     } catch (std::exception& e) {
11070       {
11071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11072       };
11073     } catch (Dali::DaliException e) {
11074       {
11075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11076       };
11077     } catch (...) {
11078       {
11079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11080       };
11081     }
11082   }
11083
11084   jresult = result;
11085   return jresult;
11086 }
11087
11088
11089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11090   void * jresult ;
11091   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11092   Dali::Quaternion *arg2 = 0 ;
11093   Dali::Quaternion result;
11094
11095   arg1 = (Dali::Quaternion *)jarg1;
11096   arg2 = (Dali::Quaternion *)jarg2;
11097   if (!arg2) {
11098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11099     return 0;
11100   }
11101   {
11102     try {
11103       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11104     } catch (std::out_of_range& e) {
11105       {
11106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11107       };
11108     } catch (std::exception& e) {
11109       {
11110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11111       };
11112     } catch (Dali::DaliException e) {
11113       {
11114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11115       };
11116     } catch (...) {
11117       {
11118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11119       };
11120     }
11121   }
11122
11123   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11124   return jresult;
11125 }
11126
11127
11128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11129   void * jresult ;
11130   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11131   Dali::Quaternion *arg2 = 0 ;
11132   Dali::Quaternion result;
11133
11134   arg1 = (Dali::Quaternion *)jarg1;
11135   arg2 = (Dali::Quaternion *)jarg2;
11136   if (!arg2) {
11137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11138     return 0;
11139   }
11140   {
11141     try {
11142       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11143     } catch (std::out_of_range& e) {
11144       {
11145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11146       };
11147     } catch (std::exception& e) {
11148       {
11149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11150       };
11151     } catch (Dali::DaliException e) {
11152       {
11153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11154       };
11155     } catch (...) {
11156       {
11157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11158       };
11159     }
11160   }
11161
11162   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11163   return jresult;
11164 }
11165
11166
11167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11168   void * jresult ;
11169   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11170   Dali::Quaternion *arg2 = 0 ;
11171   Dali::Quaternion result;
11172
11173   arg1 = (Dali::Quaternion *)jarg1;
11174   arg2 = (Dali::Quaternion *)jarg2;
11175   if (!arg2) {
11176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11177     return 0;
11178   }
11179   {
11180     try {
11181       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11182     } catch (std::out_of_range& e) {
11183       {
11184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11185       };
11186     } catch (std::exception& e) {
11187       {
11188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11189       };
11190     } catch (Dali::DaliException e) {
11191       {
11192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11193       };
11194     } catch (...) {
11195       {
11196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11197       };
11198     }
11199   }
11200
11201   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11202   return jresult;
11203 }
11204
11205
11206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11207   void * jresult ;
11208   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11209   Dali::Vector3 *arg2 = 0 ;
11210   Dali::Vector3 result;
11211
11212   arg1 = (Dali::Quaternion *)jarg1;
11213   arg2 = (Dali::Vector3 *)jarg2;
11214   if (!arg2) {
11215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11216     return 0;
11217   }
11218   {
11219     try {
11220       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11221     } catch (std::out_of_range& e) {
11222       {
11223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11224       };
11225     } catch (std::exception& e) {
11226       {
11227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11228       };
11229     } catch (Dali::DaliException e) {
11230       {
11231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11232       };
11233     } catch (...) {
11234       {
11235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11236       };
11237     }
11238   }
11239
11240   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11241   return jresult;
11242 }
11243
11244
11245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11246   void * jresult ;
11247   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11248   Dali::Quaternion *arg2 = 0 ;
11249   Dali::Quaternion result;
11250
11251   arg1 = (Dali::Quaternion *)jarg1;
11252   arg2 = (Dali::Quaternion *)jarg2;
11253   if (!arg2) {
11254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11255     return 0;
11256   }
11257   {
11258     try {
11259       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11260     } catch (std::out_of_range& e) {
11261       {
11262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11263       };
11264     } catch (std::exception& e) {
11265       {
11266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11267       };
11268     } catch (Dali::DaliException e) {
11269       {
11270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11271       };
11272     } catch (...) {
11273       {
11274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11275       };
11276     }
11277   }
11278
11279   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11280   return jresult;
11281 }
11282
11283
11284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11285   void * jresult ;
11286   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11287   float arg2 ;
11288   Dali::Quaternion result;
11289
11290   arg1 = (Dali::Quaternion *)jarg1;
11291   arg2 = (float)jarg2;
11292   {
11293     try {
11294       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11295     } catch (std::out_of_range& e) {
11296       {
11297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11298       };
11299     } catch (std::exception& e) {
11300       {
11301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11302       };
11303     } catch (Dali::DaliException e) {
11304       {
11305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11306       };
11307     } catch (...) {
11308       {
11309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11310       };
11311     }
11312   }
11313
11314   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11315   return jresult;
11316 }
11317
11318
11319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11320   void * jresult ;
11321   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11322   float arg2 ;
11323   Dali::Quaternion result;
11324
11325   arg1 = (Dali::Quaternion *)jarg1;
11326   arg2 = (float)jarg2;
11327   {
11328     try {
11329       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11330     } catch (std::out_of_range& e) {
11331       {
11332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11333       };
11334     } catch (std::exception& e) {
11335       {
11336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11337       };
11338     } catch (Dali::DaliException e) {
11339       {
11340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11341       };
11342     } catch (...) {
11343       {
11344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11345       };
11346     }
11347   }
11348
11349   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11350   return jresult;
11351 }
11352
11353
11354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11355   void * jresult ;
11356   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11357   Dali::Quaternion result;
11358
11359   arg1 = (Dali::Quaternion *)jarg1;
11360   {
11361     try {
11362       result = ((Dali::Quaternion const *)arg1)->operator -();
11363     } catch (std::out_of_range& e) {
11364       {
11365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11366       };
11367     } catch (std::exception& e) {
11368       {
11369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11370       };
11371     } catch (Dali::DaliException e) {
11372       {
11373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11374       };
11375     } catch (...) {
11376       {
11377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11378       };
11379     }
11380   }
11381
11382   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11383   return jresult;
11384 }
11385
11386
11387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11388   void * jresult ;
11389   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11390   Dali::Quaternion *arg2 = 0 ;
11391   Dali::Quaternion *result = 0 ;
11392
11393   arg1 = (Dali::Quaternion *)jarg1;
11394   arg2 = (Dali::Quaternion *)jarg2;
11395   if (!arg2) {
11396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11397     return 0;
11398   }
11399   {
11400     try {
11401       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11402     } catch (std::out_of_range& e) {
11403       {
11404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11405       };
11406     } catch (std::exception& e) {
11407       {
11408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11409       };
11410     } catch (Dali::DaliException e) {
11411       {
11412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11413       };
11414     } catch (...) {
11415       {
11416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11417       };
11418     }
11419   }
11420
11421   jresult = (void *)result;
11422   return jresult;
11423 }
11424
11425
11426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11427   void * jresult ;
11428   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11429   Dali::Quaternion *arg2 = 0 ;
11430   Dali::Quaternion *result = 0 ;
11431
11432   arg1 = (Dali::Quaternion *)jarg1;
11433   arg2 = (Dali::Quaternion *)jarg2;
11434   if (!arg2) {
11435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11436     return 0;
11437   }
11438   {
11439     try {
11440       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11441     } catch (std::out_of_range& e) {
11442       {
11443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11444       };
11445     } catch (std::exception& e) {
11446       {
11447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11448       };
11449     } catch (Dali::DaliException e) {
11450       {
11451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11452       };
11453     } catch (...) {
11454       {
11455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11456       };
11457     }
11458   }
11459
11460   jresult = (void *)result;
11461   return jresult;
11462 }
11463
11464
11465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11466   void * jresult ;
11467   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11468   Dali::Quaternion *arg2 = 0 ;
11469   Dali::Quaternion *result = 0 ;
11470
11471   arg1 = (Dali::Quaternion *)jarg1;
11472   arg2 = (Dali::Quaternion *)jarg2;
11473   if (!arg2) {
11474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11475     return 0;
11476   }
11477   {
11478     try {
11479       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11480     } catch (std::out_of_range& e) {
11481       {
11482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11483       };
11484     } catch (std::exception& e) {
11485       {
11486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11487       };
11488     } catch (Dali::DaliException e) {
11489       {
11490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11491       };
11492     } catch (...) {
11493       {
11494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11495       };
11496     }
11497   }
11498
11499   jresult = (void *)result;
11500   return jresult;
11501 }
11502
11503
11504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11505   void * jresult ;
11506   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11507   float arg2 ;
11508   Dali::Quaternion *result = 0 ;
11509
11510   arg1 = (Dali::Quaternion *)jarg1;
11511   arg2 = (float)jarg2;
11512   {
11513     try {
11514       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11515     } catch (std::out_of_range& e) {
11516       {
11517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11518       };
11519     } catch (std::exception& e) {
11520       {
11521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11522       };
11523     } catch (Dali::DaliException e) {
11524       {
11525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11526       };
11527     } catch (...) {
11528       {
11529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11530       };
11531     }
11532   }
11533
11534   jresult = (void *)result;
11535   return jresult;
11536 }
11537
11538
11539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11540   void * jresult ;
11541   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11542   float arg2 ;
11543   Dali::Quaternion *result = 0 ;
11544
11545   arg1 = (Dali::Quaternion *)jarg1;
11546   arg2 = (float)jarg2;
11547   {
11548     try {
11549       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11550     } catch (std::out_of_range& e) {
11551       {
11552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11553       };
11554     } catch (std::exception& e) {
11555       {
11556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11557       };
11558     } catch (Dali::DaliException e) {
11559       {
11560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11561       };
11562     } catch (...) {
11563       {
11564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11565       };
11566     }
11567   }
11568
11569   jresult = (void *)result;
11570   return jresult;
11571 }
11572
11573
11574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11575   unsigned int jresult ;
11576   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11577   Dali::Quaternion *arg2 = 0 ;
11578   bool result;
11579
11580   arg1 = (Dali::Quaternion *)jarg1;
11581   arg2 = (Dali::Quaternion *)jarg2;
11582   if (!arg2) {
11583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11584     return 0;
11585   }
11586   {
11587     try {
11588       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11589     } catch (std::out_of_range& e) {
11590       {
11591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11592       };
11593     } catch (std::exception& e) {
11594       {
11595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11596       };
11597     } catch (Dali::DaliException e) {
11598       {
11599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11600       };
11601     } catch (...) {
11602       {
11603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11604       };
11605     }
11606   }
11607
11608   jresult = result;
11609   return jresult;
11610 }
11611
11612
11613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11614   unsigned int jresult ;
11615   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11616   Dali::Quaternion *arg2 = 0 ;
11617   bool result;
11618
11619   arg1 = (Dali::Quaternion *)jarg1;
11620   arg2 = (Dali::Quaternion *)jarg2;
11621   if (!arg2) {
11622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11623     return 0;
11624   }
11625   {
11626     try {
11627       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11628     } catch (std::out_of_range& e) {
11629       {
11630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11631       };
11632     } catch (std::exception& e) {
11633       {
11634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11635       };
11636     } catch (Dali::DaliException e) {
11637       {
11638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11639       };
11640     } catch (...) {
11641       {
11642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11643       };
11644     }
11645   }
11646
11647   jresult = result;
11648   return jresult;
11649 }
11650
11651
11652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11653   float jresult ;
11654   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11655   float result;
11656
11657   arg1 = (Dali::Quaternion *)jarg1;
11658   {
11659     try {
11660       result = (float)((Dali::Quaternion const *)arg1)->Length();
11661     } catch (std::out_of_range& e) {
11662       {
11663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11664       };
11665     } catch (std::exception& e) {
11666       {
11667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11668       };
11669     } catch (Dali::DaliException e) {
11670       {
11671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11672       };
11673     } catch (...) {
11674       {
11675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11676       };
11677     }
11678   }
11679
11680   jresult = result;
11681   return jresult;
11682 }
11683
11684
11685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11686   float jresult ;
11687   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11688   float result;
11689
11690   arg1 = (Dali::Quaternion *)jarg1;
11691   {
11692     try {
11693       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11694     } catch (std::out_of_range& e) {
11695       {
11696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11697       };
11698     } catch (std::exception& e) {
11699       {
11700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11701       };
11702     } catch (Dali::DaliException e) {
11703       {
11704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11705       };
11706     } catch (...) {
11707       {
11708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11709       };
11710     }
11711   }
11712
11713   jresult = result;
11714   return jresult;
11715 }
11716
11717
11718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11719   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11720
11721   arg1 = (Dali::Quaternion *)jarg1;
11722   {
11723     try {
11724       (arg1)->Normalize();
11725     } catch (std::out_of_range& e) {
11726       {
11727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11728       };
11729     } catch (std::exception& e) {
11730       {
11731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11732       };
11733     } catch (Dali::DaliException e) {
11734       {
11735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11736       };
11737     } catch (...) {
11738       {
11739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11740       };
11741     }
11742   }
11743
11744 }
11745
11746
11747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11748   void * jresult ;
11749   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11750   Dali::Quaternion result;
11751
11752   arg1 = (Dali::Quaternion *)jarg1;
11753   {
11754     try {
11755       result = ((Dali::Quaternion const *)arg1)->Normalized();
11756     } catch (std::out_of_range& e) {
11757       {
11758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11759       };
11760     } catch (std::exception& e) {
11761       {
11762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11763       };
11764     } catch (Dali::DaliException e) {
11765       {
11766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11767       };
11768     } catch (...) {
11769       {
11770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11771       };
11772     }
11773   }
11774
11775   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11776   return jresult;
11777 }
11778
11779
11780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11781   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11782
11783   arg1 = (Dali::Quaternion *)jarg1;
11784   {
11785     try {
11786       (arg1)->Conjugate();
11787     } catch (std::out_of_range& e) {
11788       {
11789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11790       };
11791     } catch (std::exception& e) {
11792       {
11793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11794       };
11795     } catch (Dali::DaliException e) {
11796       {
11797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11798       };
11799     } catch (...) {
11800       {
11801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11802       };
11803     }
11804   }
11805
11806 }
11807
11808
11809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11810   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11811
11812   arg1 = (Dali::Quaternion *)jarg1;
11813   {
11814     try {
11815       (arg1)->Invert();
11816     } catch (std::out_of_range& e) {
11817       {
11818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11819       };
11820     } catch (std::exception& e) {
11821       {
11822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11823       };
11824     } catch (Dali::DaliException e) {
11825       {
11826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11827       };
11828     } catch (...) {
11829       {
11830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11831       };
11832     }
11833   }
11834
11835 }
11836
11837
11838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11839   void * jresult ;
11840   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11841   Dali::Quaternion result;
11842
11843   arg1 = (Dali::Quaternion *)jarg1;
11844   {
11845     try {
11846       result = ((Dali::Quaternion const *)arg1)->Log();
11847     } catch (std::out_of_range& e) {
11848       {
11849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11850       };
11851     } catch (std::exception& e) {
11852       {
11853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11854       };
11855     } catch (Dali::DaliException e) {
11856       {
11857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11858       };
11859     } catch (...) {
11860       {
11861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11862       };
11863     }
11864   }
11865
11866   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11867   return jresult;
11868 }
11869
11870
11871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11872   void * jresult ;
11873   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11874   Dali::Quaternion result;
11875
11876   arg1 = (Dali::Quaternion *)jarg1;
11877   {
11878     try {
11879       result = ((Dali::Quaternion const *)arg1)->Exp();
11880     } catch (std::out_of_range& e) {
11881       {
11882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11883       };
11884     } catch (std::exception& e) {
11885       {
11886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11887       };
11888     } catch (Dali::DaliException e) {
11889       {
11890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11891       };
11892     } catch (...) {
11893       {
11894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11895       };
11896     }
11897   }
11898
11899   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11900   return jresult;
11901 }
11902
11903
11904 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11905   float jresult ;
11906   Dali::Quaternion *arg1 = 0 ;
11907   Dali::Quaternion *arg2 = 0 ;
11908   float result;
11909
11910   arg1 = (Dali::Quaternion *)jarg1;
11911   if (!arg1) {
11912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11913     return 0;
11914   }
11915   arg2 = (Dali::Quaternion *)jarg2;
11916   if (!arg2) {
11917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11918     return 0;
11919   }
11920   {
11921     try {
11922       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11923     } catch (std::out_of_range& e) {
11924       {
11925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11926       };
11927     } catch (std::exception& e) {
11928       {
11929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11930       };
11931     } catch (Dali::DaliException e) {
11932       {
11933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11934       };
11935     } catch (...) {
11936       {
11937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11938       };
11939     }
11940   }
11941
11942   jresult = result;
11943   return jresult;
11944 }
11945
11946
11947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11948   void * jresult ;
11949   Dali::Quaternion *arg1 = 0 ;
11950   Dali::Quaternion *arg2 = 0 ;
11951   float arg3 ;
11952   Dali::Quaternion result;
11953
11954   arg1 = (Dali::Quaternion *)jarg1;
11955   if (!arg1) {
11956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11957     return 0;
11958   }
11959   arg2 = (Dali::Quaternion *)jarg2;
11960   if (!arg2) {
11961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11962     return 0;
11963   }
11964   arg3 = (float)jarg3;
11965   {
11966     try {
11967       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11968     } catch (std::out_of_range& e) {
11969       {
11970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11971       };
11972     } catch (std::exception& e) {
11973       {
11974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11975       };
11976     } catch (Dali::DaliException e) {
11977       {
11978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11979       };
11980     } catch (...) {
11981       {
11982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11983       };
11984     }
11985   }
11986
11987   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11988   return jresult;
11989 }
11990
11991
11992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11993   void * jresult ;
11994   Dali::Quaternion *arg1 = 0 ;
11995   Dali::Quaternion *arg2 = 0 ;
11996   float arg3 ;
11997   Dali::Quaternion result;
11998
11999   arg1 = (Dali::Quaternion *)jarg1;
12000   if (!arg1) {
12001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12002     return 0;
12003   }
12004   arg2 = (Dali::Quaternion *)jarg2;
12005   if (!arg2) {
12006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12007     return 0;
12008   }
12009   arg3 = (float)jarg3;
12010   {
12011     try {
12012       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12013     } catch (std::out_of_range& e) {
12014       {
12015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12016       };
12017     } catch (std::exception& e) {
12018       {
12019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12020       };
12021     } catch (Dali::DaliException e) {
12022       {
12023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12024       };
12025     } catch (...) {
12026       {
12027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12028       };
12029     }
12030   }
12031
12032   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12033   return jresult;
12034 }
12035
12036
12037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12038   void * jresult ;
12039   Dali::Quaternion *arg1 = 0 ;
12040   Dali::Quaternion *arg2 = 0 ;
12041   float arg3 ;
12042   Dali::Quaternion result;
12043
12044   arg1 = (Dali::Quaternion *)jarg1;
12045   if (!arg1) {
12046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12047     return 0;
12048   }
12049   arg2 = (Dali::Quaternion *)jarg2;
12050   if (!arg2) {
12051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12052     return 0;
12053   }
12054   arg3 = (float)jarg3;
12055   {
12056     try {
12057       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12058     } catch (std::out_of_range& e) {
12059       {
12060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12061       };
12062     } catch (std::exception& e) {
12063       {
12064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12065       };
12066     } catch (Dali::DaliException e) {
12067       {
12068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12069       };
12070     } catch (...) {
12071       {
12072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12073       };
12074     }
12075   }
12076
12077   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12078   return jresult;
12079 }
12080
12081
12082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12083   void * jresult ;
12084   Dali::Quaternion *arg1 = 0 ;
12085   Dali::Quaternion *arg2 = 0 ;
12086   Dali::Quaternion *arg3 = 0 ;
12087   Dali::Quaternion *arg4 = 0 ;
12088   float arg5 ;
12089   Dali::Quaternion result;
12090
12091   arg1 = (Dali::Quaternion *)jarg1;
12092   if (!arg1) {
12093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12094     return 0;
12095   }
12096   arg2 = (Dali::Quaternion *)jarg2;
12097   if (!arg2) {
12098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12099     return 0;
12100   }
12101   arg3 = (Dali::Quaternion *)jarg3;
12102   if (!arg3) {
12103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12104     return 0;
12105   }
12106   arg4 = (Dali::Quaternion *)jarg4;
12107   if (!arg4) {
12108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12109     return 0;
12110   }
12111   arg5 = (float)jarg5;
12112   {
12113     try {
12114       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12115     } catch (std::out_of_range& e) {
12116       {
12117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12118       };
12119     } catch (std::exception& e) {
12120       {
12121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12122       };
12123     } catch (Dali::DaliException e) {
12124       {
12125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12126       };
12127     } catch (...) {
12128       {
12129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12130       };
12131     }
12132   }
12133
12134   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12135   return jresult;
12136 }
12137
12138
12139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12140   float jresult ;
12141   Dali::Quaternion *arg1 = 0 ;
12142   Dali::Quaternion *arg2 = 0 ;
12143   float result;
12144
12145   arg1 = (Dali::Quaternion *)jarg1;
12146   if (!arg1) {
12147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12148     return 0;
12149   }
12150   arg2 = (Dali::Quaternion *)jarg2;
12151   if (!arg2) {
12152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12153     return 0;
12154   }
12155   {
12156     try {
12157       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12158     } catch (std::out_of_range& e) {
12159       {
12160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12161       };
12162     } catch (std::exception& e) {
12163       {
12164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12165       };
12166     } catch (Dali::DaliException e) {
12167       {
12168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12169       };
12170     } catch (...) {
12171       {
12172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12173       };
12174     }
12175   }
12176
12177   jresult = result;
12178   return jresult;
12179 }
12180
12181
12182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12183   void * jresult ;
12184   Dali::Matrix *result = 0 ;
12185
12186   {
12187     try {
12188       result = (Dali::Matrix *)new Dali::Matrix();
12189     } catch (std::out_of_range& e) {
12190       {
12191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12192       };
12193     } catch (std::exception& e) {
12194       {
12195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12196       };
12197     } catch (Dali::DaliException e) {
12198       {
12199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12200       };
12201     } catch (...) {
12202       {
12203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12204       };
12205     }
12206   }
12207
12208   jresult = (void *)result;
12209   return jresult;
12210 }
12211
12212
12213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12214   void * jresult ;
12215   bool arg1 ;
12216   Dali::Matrix *result = 0 ;
12217
12218   arg1 = jarg1 ? true : false;
12219   {
12220     try {
12221       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12222     } catch (std::out_of_range& e) {
12223       {
12224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12225       };
12226     } catch (std::exception& e) {
12227       {
12228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12229       };
12230     } catch (Dali::DaliException e) {
12231       {
12232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12233       };
12234     } catch (...) {
12235       {
12236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12237       };
12238     }
12239   }
12240
12241   jresult = (void *)result;
12242   return jresult;
12243 }
12244
12245
12246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12247   void * jresult ;
12248   float *arg1 = (float *) 0 ;
12249   Dali::Matrix *result = 0 ;
12250
12251   arg1 = jarg1;
12252   {
12253     try {
12254       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12255     } catch (std::out_of_range& e) {
12256       {
12257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12258       };
12259     } catch (std::exception& e) {
12260       {
12261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12262       };
12263     } catch (Dali::DaliException e) {
12264       {
12265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12266       };
12267     } catch (...) {
12268       {
12269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12270       };
12271     }
12272   }
12273
12274   jresult = (void *)result;
12275
12276
12277   return jresult;
12278 }
12279
12280
12281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12282   void * jresult ;
12283   Dali::Quaternion *arg1 = 0 ;
12284   Dali::Matrix *result = 0 ;
12285
12286   arg1 = (Dali::Quaternion *)jarg1;
12287   if (!arg1) {
12288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12289     return 0;
12290   }
12291   {
12292     try {
12293       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12294     } catch (std::out_of_range& e) {
12295       {
12296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12297       };
12298     } catch (std::exception& e) {
12299       {
12300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12301       };
12302     } catch (Dali::DaliException e) {
12303       {
12304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12305       };
12306     } catch (...) {
12307       {
12308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12309       };
12310     }
12311   }
12312
12313   jresult = (void *)result;
12314   return jresult;
12315 }
12316
12317
12318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12319   void * jresult ;
12320   Dali::Matrix *arg1 = 0 ;
12321   Dali::Matrix *result = 0 ;
12322
12323   arg1 = (Dali::Matrix *)jarg1;
12324   if (!arg1) {
12325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12326     return 0;
12327   }
12328   {
12329     try {
12330       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12331     } catch (std::out_of_range& e) {
12332       {
12333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12334       };
12335     } catch (std::exception& e) {
12336       {
12337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12338       };
12339     } catch (Dali::DaliException e) {
12340       {
12341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12342       };
12343     } catch (...) {
12344       {
12345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12346       };
12347     }
12348   }
12349
12350   jresult = (void *)result;
12351   return jresult;
12352 }
12353
12354
12355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12356   void * jresult ;
12357   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12358   Dali::Matrix *arg2 = 0 ;
12359   Dali::Matrix *result = 0 ;
12360
12361   arg1 = (Dali::Matrix *)jarg1;
12362   arg2 = (Dali::Matrix *)jarg2;
12363   if (!arg2) {
12364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12365     return 0;
12366   }
12367   {
12368     try {
12369       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12370     } catch (std::out_of_range& e) {
12371       {
12372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12373       };
12374     } catch (std::exception& e) {
12375       {
12376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12377       };
12378     } catch (Dali::DaliException e) {
12379       {
12380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12381       };
12382     } catch (...) {
12383       {
12384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12385       };
12386     }
12387   }
12388
12389   jresult = (void *)result;
12390   return jresult;
12391 }
12392
12393
12394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12395   void * jresult ;
12396   Dali::Matrix *result = 0 ;
12397
12398   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12399   jresult = (void *)result;
12400   return jresult;
12401 }
12402
12403
12404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12405   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12406
12407   arg1 = (Dali::Matrix *)jarg1;
12408   {
12409     try {
12410       (arg1)->SetIdentity();
12411     } catch (std::out_of_range& e) {
12412       {
12413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12414       };
12415     } catch (std::exception& e) {
12416       {
12417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12418       };
12419     } catch (Dali::DaliException e) {
12420       {
12421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12422       };
12423     } catch (...) {
12424       {
12425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12426       };
12427     }
12428   }
12429
12430 }
12431
12432
12433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12434   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12435   Dali::Vector3 *arg2 = 0 ;
12436
12437   arg1 = (Dali::Matrix *)jarg1;
12438   arg2 = (Dali::Vector3 *)jarg2;
12439   if (!arg2) {
12440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12441     return ;
12442   }
12443   {
12444     try {
12445       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12446     } catch (std::out_of_range& e) {
12447       {
12448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12449       };
12450     } catch (std::exception& e) {
12451       {
12452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12453       };
12454     } catch (Dali::DaliException e) {
12455       {
12456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12457       };
12458     } catch (...) {
12459       {
12460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12461       };
12462     }
12463   }
12464
12465 }
12466
12467
12468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12469   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12470   Dali::Matrix *arg2 = 0 ;
12471
12472   arg1 = (Dali::Matrix *)jarg1;
12473   arg2 = (Dali::Matrix *)jarg2;
12474   if (!arg2) {
12475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12476     return ;
12477   }
12478   {
12479     try {
12480       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12481     } catch (std::out_of_range& e) {
12482       {
12483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12484       };
12485     } catch (std::exception& e) {
12486       {
12487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12488       };
12489     } catch (Dali::DaliException e) {
12490       {
12491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12492       };
12493     } catch (...) {
12494       {
12495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12496       };
12497     }
12498   }
12499
12500 }
12501
12502
12503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12504   unsigned int jresult ;
12505   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12506   bool result;
12507
12508   arg1 = (Dali::Matrix *)jarg1;
12509   {
12510     try {
12511       result = (bool)(arg1)->Invert();
12512     } catch (std::out_of_range& e) {
12513       {
12514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12515       };
12516     } catch (std::exception& e) {
12517       {
12518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12519       };
12520     } catch (Dali::DaliException e) {
12521       {
12522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12523       };
12524     } catch (...) {
12525       {
12526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12527       };
12528     }
12529   }
12530
12531   jresult = result;
12532   return jresult;
12533 }
12534
12535
12536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12537   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12538
12539   arg1 = (Dali::Matrix *)jarg1;
12540   {
12541     try {
12542       (arg1)->Transpose();
12543     } catch (std::out_of_range& e) {
12544       {
12545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12546       };
12547     } catch (std::exception& e) {
12548       {
12549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12550       };
12551     } catch (Dali::DaliException e) {
12552       {
12553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12554       };
12555     } catch (...) {
12556       {
12557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12558       };
12559     }
12560   }
12561
12562 }
12563
12564
12565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12566   void * jresult ;
12567   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12568   Dali::Vector3 result;
12569
12570   arg1 = (Dali::Matrix *)jarg1;
12571   {
12572     try {
12573       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12574     } catch (std::out_of_range& e) {
12575       {
12576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12577       };
12578     } catch (std::exception& e) {
12579       {
12580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12581       };
12582     } catch (Dali::DaliException e) {
12583       {
12584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12585       };
12586     } catch (...) {
12587       {
12588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12589       };
12590     }
12591   }
12592
12593   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12594   return jresult;
12595 }
12596
12597
12598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12599   void * jresult ;
12600   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12601   Dali::Vector3 result;
12602
12603   arg1 = (Dali::Matrix *)jarg1;
12604   {
12605     try {
12606       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12607     } catch (std::out_of_range& e) {
12608       {
12609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12610       };
12611     } catch (std::exception& e) {
12612       {
12613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12614       };
12615     } catch (Dali::DaliException e) {
12616       {
12617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12618       };
12619     } catch (...) {
12620       {
12621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12622       };
12623     }
12624   }
12625
12626   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12627   return jresult;
12628 }
12629
12630
12631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12632   void * jresult ;
12633   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12634   Dali::Vector3 result;
12635
12636   arg1 = (Dali::Matrix *)jarg1;
12637   {
12638     try {
12639       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12640     } catch (std::out_of_range& e) {
12641       {
12642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12643       };
12644     } catch (std::exception& e) {
12645       {
12646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12647       };
12648     } catch (Dali::DaliException e) {
12649       {
12650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12651       };
12652     } catch (...) {
12653       {
12654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12655       };
12656     }
12657   }
12658
12659   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12660   return jresult;
12661 }
12662
12663
12664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12665   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12666   Dali::Vector3 *arg2 = 0 ;
12667
12668   arg1 = (Dali::Matrix *)jarg1;
12669   arg2 = (Dali::Vector3 *)jarg2;
12670   if (!arg2) {
12671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12672     return ;
12673   }
12674   {
12675     try {
12676       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12677     } catch (std::out_of_range& e) {
12678       {
12679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12680       };
12681     } catch (std::exception& e) {
12682       {
12683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12684       };
12685     } catch (Dali::DaliException e) {
12686       {
12687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12688       };
12689     } catch (...) {
12690       {
12691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12692       };
12693     }
12694   }
12695
12696 }
12697
12698
12699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12700   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12701   Dali::Vector3 *arg2 = 0 ;
12702
12703   arg1 = (Dali::Matrix *)jarg1;
12704   arg2 = (Dali::Vector3 *)jarg2;
12705   if (!arg2) {
12706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12707     return ;
12708   }
12709   {
12710     try {
12711       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12712     } catch (std::out_of_range& e) {
12713       {
12714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12715       };
12716     } catch (std::exception& e) {
12717       {
12718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12719       };
12720     } catch (Dali::DaliException e) {
12721       {
12722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12723       };
12724     } catch (...) {
12725       {
12726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12727       };
12728     }
12729   }
12730
12731 }
12732
12733
12734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12735   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12736   Dali::Vector3 *arg2 = 0 ;
12737
12738   arg1 = (Dali::Matrix *)jarg1;
12739   arg2 = (Dali::Vector3 *)jarg2;
12740   if (!arg2) {
12741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12742     return ;
12743   }
12744   {
12745     try {
12746       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12747     } catch (std::out_of_range& e) {
12748       {
12749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12750       };
12751     } catch (std::exception& e) {
12752       {
12753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12754       };
12755     } catch (Dali::DaliException e) {
12756       {
12757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12758       };
12759     } catch (...) {
12760       {
12761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12762       };
12763     }
12764   }
12765
12766 }
12767
12768
12769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12770   void * jresult ;
12771   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12772   Dali::Vector4 *result = 0 ;
12773
12774   arg1 = (Dali::Matrix *)jarg1;
12775   {
12776     try {
12777       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12778     } catch (std::out_of_range& e) {
12779       {
12780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12781       };
12782     } catch (std::exception& e) {
12783       {
12784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12785       };
12786     } catch (Dali::DaliException e) {
12787       {
12788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12789       };
12790     } catch (...) {
12791       {
12792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12793       };
12794     }
12795   }
12796
12797   jresult = (void *)result;
12798   return jresult;
12799 }
12800
12801
12802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12803   void * jresult ;
12804   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12805   Dali::Vector3 *result = 0 ;
12806
12807   arg1 = (Dali::Matrix *)jarg1;
12808   {
12809     try {
12810       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12811     } catch (std::out_of_range& e) {
12812       {
12813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12814       };
12815     } catch (std::exception& e) {
12816       {
12817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12818       };
12819     } catch (Dali::DaliException e) {
12820       {
12821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12822       };
12823     } catch (...) {
12824       {
12825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12826       };
12827     }
12828   }
12829
12830   jresult = (void *)result;
12831   return jresult;
12832 }
12833
12834
12835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12836   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12837   Dali::Vector4 *arg2 = 0 ;
12838
12839   arg1 = (Dali::Matrix *)jarg1;
12840   arg2 = (Dali::Vector4 *)jarg2;
12841   if (!arg2) {
12842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12843     return ;
12844   }
12845   {
12846     try {
12847       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12848     } catch (std::out_of_range& e) {
12849       {
12850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12851       };
12852     } catch (std::exception& e) {
12853       {
12854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12855       };
12856     } catch (Dali::DaliException e) {
12857       {
12858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12859       };
12860     } catch (...) {
12861       {
12862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12863       };
12864     }
12865   }
12866
12867 }
12868
12869
12870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12871   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12872   Dali::Vector3 *arg2 = 0 ;
12873
12874   arg1 = (Dali::Matrix *)jarg1;
12875   arg2 = (Dali::Vector3 *)jarg2;
12876   if (!arg2) {
12877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12878     return ;
12879   }
12880   {
12881     try {
12882       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12883     } catch (std::out_of_range& e) {
12884       {
12885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12886       };
12887     } catch (std::exception& e) {
12888       {
12889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12890       };
12891     } catch (Dali::DaliException e) {
12892       {
12893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12894       };
12895     } catch (...) {
12896       {
12897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12898       };
12899     }
12900   }
12901
12902 }
12903
12904
12905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12906   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12907
12908   arg1 = (Dali::Matrix *)jarg1;
12909   {
12910     try {
12911       (arg1)->OrthoNormalize();
12912     } catch (std::out_of_range& e) {
12913       {
12914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12915       };
12916     } catch (std::exception& e) {
12917       {
12918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12919       };
12920     } catch (Dali::DaliException e) {
12921       {
12922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12923       };
12924     } catch (...) {
12925       {
12926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12927       };
12928     }
12929   }
12930
12931 }
12932
12933
12934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12935   void * jresult ;
12936   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12937   float *result = 0 ;
12938
12939   arg1 = (Dali::Matrix *)jarg1;
12940   {
12941     try {
12942       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12943     } catch (std::out_of_range& e) {
12944       {
12945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12946       };
12947     } catch (std::exception& e) {
12948       {
12949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12950       };
12951     } catch (Dali::DaliException e) {
12952       {
12953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12954       };
12955     } catch (...) {
12956       {
12957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12958       };
12959     }
12960   }
12961
12962   jresult = (void *)result;
12963   return jresult;
12964 }
12965
12966
12967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12968   Dali::Matrix *arg1 = 0 ;
12969   Dali::Matrix *arg2 = 0 ;
12970   Dali::Matrix *arg3 = 0 ;
12971
12972   arg1 = (Dali::Matrix *)jarg1;
12973   if (!arg1) {
12974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12975     return ;
12976   }
12977   arg2 = (Dali::Matrix *)jarg2;
12978   if (!arg2) {
12979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12980     return ;
12981   }
12982   arg3 = (Dali::Matrix *)jarg3;
12983   if (!arg3) {
12984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12985     return ;
12986   }
12987   {
12988     try {
12989       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12990     } catch (std::out_of_range& e) {
12991       {
12992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12993       };
12994     } catch (std::exception& e) {
12995       {
12996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12997       };
12998     } catch (Dali::DaliException e) {
12999       {
13000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13001       };
13002     } catch (...) {
13003       {
13004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13005       };
13006     }
13007   }
13008
13009 }
13010
13011
13012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13013   Dali::Matrix *arg1 = 0 ;
13014   Dali::Matrix *arg2 = 0 ;
13015   Dali::Quaternion *arg3 = 0 ;
13016
13017   arg1 = (Dali::Matrix *)jarg1;
13018   if (!arg1) {
13019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13020     return ;
13021   }
13022   arg2 = (Dali::Matrix *)jarg2;
13023   if (!arg2) {
13024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13025     return ;
13026   }
13027   arg3 = (Dali::Quaternion *)jarg3;
13028   if (!arg3) {
13029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13030     return ;
13031   }
13032   {
13033     try {
13034       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13035     } catch (std::out_of_range& e) {
13036       {
13037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13038       };
13039     } catch (std::exception& e) {
13040       {
13041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13042       };
13043     } catch (Dali::DaliException e) {
13044       {
13045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13046       };
13047     } catch (...) {
13048       {
13049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13050       };
13051     }
13052   }
13053
13054 }
13055
13056
13057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13058   void * jresult ;
13059   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13060   Dali::Vector4 *arg2 = 0 ;
13061   Dali::Vector4 result;
13062
13063   arg1 = (Dali::Matrix *)jarg1;
13064   arg2 = (Dali::Vector4 *)jarg2;
13065   if (!arg2) {
13066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13067     return 0;
13068   }
13069   {
13070     try {
13071       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13072     } catch (std::out_of_range& e) {
13073       {
13074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13075       };
13076     } catch (std::exception& e) {
13077       {
13078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13079       };
13080     } catch (Dali::DaliException e) {
13081       {
13082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13083       };
13084     } catch (...) {
13085       {
13086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13087       };
13088     }
13089   }
13090
13091   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13092   return jresult;
13093 }
13094
13095
13096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13097   unsigned int jresult ;
13098   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13099   Dali::Matrix *arg2 = 0 ;
13100   bool result;
13101
13102   arg1 = (Dali::Matrix *)jarg1;
13103   arg2 = (Dali::Matrix *)jarg2;
13104   if (!arg2) {
13105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13106     return 0;
13107   }
13108   {
13109     try {
13110       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13111     } catch (std::out_of_range& e) {
13112       {
13113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13114       };
13115     } catch (std::exception& e) {
13116       {
13117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13118       };
13119     } catch (Dali::DaliException e) {
13120       {
13121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13122       };
13123     } catch (...) {
13124       {
13125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13126       };
13127     }
13128   }
13129
13130   jresult = result;
13131   return jresult;
13132 }
13133
13134
13135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13136   unsigned int jresult ;
13137   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13138   Dali::Matrix *arg2 = 0 ;
13139   bool result;
13140
13141   arg1 = (Dali::Matrix *)jarg1;
13142   arg2 = (Dali::Matrix *)jarg2;
13143   if (!arg2) {
13144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13145     return 0;
13146   }
13147   {
13148     try {
13149       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13150     } catch (std::out_of_range& e) {
13151       {
13152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13153       };
13154     } catch (std::exception& e) {
13155       {
13156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13157       };
13158     } catch (Dali::DaliException e) {
13159       {
13160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13161       };
13162     } catch (...) {
13163       {
13164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13165       };
13166     }
13167   }
13168
13169   jresult = result;
13170   return jresult;
13171 }
13172
13173
13174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13175   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13176   Dali::Vector3 *arg2 = 0 ;
13177   Dali::Quaternion *arg3 = 0 ;
13178   Dali::Vector3 *arg4 = 0 ;
13179
13180   arg1 = (Dali::Matrix *)jarg1;
13181   arg2 = (Dali::Vector3 *)jarg2;
13182   if (!arg2) {
13183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13184     return ;
13185   }
13186   arg3 = (Dali::Quaternion *)jarg3;
13187   if (!arg3) {
13188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13189     return ;
13190   }
13191   arg4 = (Dali::Vector3 *)jarg4;
13192   if (!arg4) {
13193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13194     return ;
13195   }
13196   {
13197     try {
13198       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13199     } catch (std::out_of_range& e) {
13200       {
13201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13202       };
13203     } catch (std::exception& e) {
13204       {
13205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13206       };
13207     } catch (Dali::DaliException e) {
13208       {
13209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13210       };
13211     } catch (...) {
13212       {
13213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13214       };
13215     }
13216   }
13217
13218 }
13219
13220
13221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13222   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13223   Dali::Vector3 *arg2 = 0 ;
13224   Dali::Quaternion *arg3 = 0 ;
13225   Dali::Vector3 *arg4 = 0 ;
13226
13227   arg1 = (Dali::Matrix *)jarg1;
13228   arg2 = (Dali::Vector3 *)jarg2;
13229   if (!arg2) {
13230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13231     return ;
13232   }
13233   arg3 = (Dali::Quaternion *)jarg3;
13234   if (!arg3) {
13235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13236     return ;
13237   }
13238   arg4 = (Dali::Vector3 *)jarg4;
13239   if (!arg4) {
13240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13241     return ;
13242   }
13243   {
13244     try {
13245       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13246     } catch (std::out_of_range& e) {
13247       {
13248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13249       };
13250     } catch (std::exception& e) {
13251       {
13252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13253       };
13254     } catch (Dali::DaliException e) {
13255       {
13256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13257       };
13258     } catch (...) {
13259       {
13260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13261       };
13262     }
13263   }
13264
13265 }
13266
13267
13268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13269   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13270   Dali::Vector3 *arg2 = 0 ;
13271   Dali::Vector3 *arg3 = 0 ;
13272   Dali::Vector3 *arg4 = 0 ;
13273   Dali::Vector3 *arg5 = 0 ;
13274
13275   arg1 = (Dali::Matrix *)jarg1;
13276   arg2 = (Dali::Vector3 *)jarg2;
13277   if (!arg2) {
13278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13279     return ;
13280   }
13281   arg3 = (Dali::Vector3 *)jarg3;
13282   if (!arg3) {
13283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13284     return ;
13285   }
13286   arg4 = (Dali::Vector3 *)jarg4;
13287   if (!arg4) {
13288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13289     return ;
13290   }
13291   arg5 = (Dali::Vector3 *)jarg5;
13292   if (!arg5) {
13293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13294     return ;
13295   }
13296   {
13297     try {
13298       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13299     } catch (std::out_of_range& e) {
13300       {
13301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13302       };
13303     } catch (std::exception& e) {
13304       {
13305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13306       };
13307     } catch (Dali::DaliException e) {
13308       {
13309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13310       };
13311     } catch (...) {
13312       {
13313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13314       };
13315     }
13316   }
13317
13318 }
13319
13320
13321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13322   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13323   Dali::Vector3 *arg2 = 0 ;
13324   Dali::Quaternion *arg3 = 0 ;
13325   Dali::Vector3 *arg4 = 0 ;
13326
13327   arg1 = (Dali::Matrix *)jarg1;
13328   arg2 = (Dali::Vector3 *)jarg2;
13329   if (!arg2) {
13330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13331     return ;
13332   }
13333   arg3 = (Dali::Quaternion *)jarg3;
13334   if (!arg3) {
13335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13336     return ;
13337   }
13338   arg4 = (Dali::Vector3 *)jarg4;
13339   if (!arg4) {
13340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13341     return ;
13342   }
13343   {
13344     try {
13345       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13346     } catch (std::out_of_range& e) {
13347       {
13348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13349       };
13350     } catch (std::exception& e) {
13351       {
13352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13353       };
13354     } catch (Dali::DaliException e) {
13355       {
13356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13357       };
13358     } catch (...) {
13359       {
13360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13361       };
13362     }
13363   }
13364
13365 }
13366
13367
13368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13369   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13370
13371   arg1 = (Dali::Matrix *)jarg1;
13372   {
13373     try {
13374       delete arg1;
13375     } catch (std::out_of_range& e) {
13376       {
13377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13378       };
13379     } catch (std::exception& e) {
13380       {
13381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13382       };
13383     } catch (Dali::DaliException e) {
13384       {
13385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13386       };
13387     } catch (...) {
13388       {
13389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13390       };
13391     }
13392   }
13393
13394 }
13395
13396
13397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13398   void * jresult ;
13399   Dali::Matrix3 *result = 0 ;
13400
13401   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13402   jresult = (void *)result;
13403   return jresult;
13404 }
13405
13406
13407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13408   void * jresult ;
13409   Dali::Matrix3 *result = 0 ;
13410
13411   {
13412     try {
13413       result = (Dali::Matrix3 *)new Dali::Matrix3();
13414     } catch (std::out_of_range& e) {
13415       {
13416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13417       };
13418     } catch (std::exception& e) {
13419       {
13420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13421       };
13422     } catch (Dali::DaliException e) {
13423       {
13424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13425       };
13426     } catch (...) {
13427       {
13428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13429       };
13430     }
13431   }
13432
13433   jresult = (void *)result;
13434   return jresult;
13435 }
13436
13437
13438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13439   void * jresult ;
13440   Dali::Matrix3 *arg1 = 0 ;
13441   Dali::Matrix3 *result = 0 ;
13442
13443   arg1 = (Dali::Matrix3 *)jarg1;
13444   if (!arg1) {
13445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13446     return 0;
13447   }
13448   {
13449     try {
13450       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13451     } catch (std::out_of_range& e) {
13452       {
13453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13454       };
13455     } catch (std::exception& e) {
13456       {
13457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13458       };
13459     } catch (Dali::DaliException e) {
13460       {
13461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13462       };
13463     } catch (...) {
13464       {
13465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13466       };
13467     }
13468   }
13469
13470   jresult = (void *)result;
13471   return jresult;
13472 }
13473
13474
13475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13476   void * jresult ;
13477   Dali::Matrix *arg1 = 0 ;
13478   Dali::Matrix3 *result = 0 ;
13479
13480   arg1 = (Dali::Matrix *)jarg1;
13481   if (!arg1) {
13482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13483     return 0;
13484   }
13485   {
13486     try {
13487       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13488     } catch (std::out_of_range& e) {
13489       {
13490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13491       };
13492     } catch (std::exception& e) {
13493       {
13494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13495       };
13496     } catch (Dali::DaliException e) {
13497       {
13498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13499       };
13500     } catch (...) {
13501       {
13502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13503       };
13504     }
13505   }
13506
13507   jresult = (void *)result;
13508   return jresult;
13509 }
13510
13511
13512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
13513   void * jresult ;
13514   float arg1 ;
13515   float arg2 ;
13516   float arg3 ;
13517   float arg4 ;
13518   float arg5 ;
13519   float arg6 ;
13520   float arg7 ;
13521   float arg8 ;
13522   float arg9 ;
13523   Dali::Matrix3 *result = 0 ;
13524
13525   arg1 = (float)jarg1;
13526   arg2 = (float)jarg2;
13527   arg3 = (float)jarg3;
13528   arg4 = (float)jarg4;
13529   arg5 = (float)jarg5;
13530   arg6 = (float)jarg6;
13531   arg7 = (float)jarg7;
13532   arg8 = (float)jarg8;
13533   arg9 = (float)jarg9;
13534   {
13535     try {
13536       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13537     } catch (std::out_of_range& e) {
13538       {
13539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13540       };
13541     } catch (std::exception& e) {
13542       {
13543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13544       };
13545     } catch (Dali::DaliException e) {
13546       {
13547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13548       };
13549     } catch (...) {
13550       {
13551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13552       };
13553     }
13554   }
13555
13556   jresult = (void *)result;
13557   return jresult;
13558 }
13559
13560
13561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13562   void * jresult ;
13563   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13564   Dali::Matrix3 *arg2 = 0 ;
13565   Dali::Matrix3 *result = 0 ;
13566
13567   arg1 = (Dali::Matrix3 *)jarg1;
13568   arg2 = (Dali::Matrix3 *)jarg2;
13569   if (!arg2) {
13570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13571     return 0;
13572   }
13573   {
13574     try {
13575       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13576     } catch (std::out_of_range& e) {
13577       {
13578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13579       };
13580     } catch (std::exception& e) {
13581       {
13582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13583       };
13584     } catch (Dali::DaliException e) {
13585       {
13586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13587       };
13588     } catch (...) {
13589       {
13590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13591       };
13592     }
13593   }
13594
13595   jresult = (void *)result;
13596   return jresult;
13597 }
13598
13599
13600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13601   void * jresult ;
13602   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13603   Dali::Matrix *arg2 = 0 ;
13604   Dali::Matrix3 *result = 0 ;
13605
13606   arg1 = (Dali::Matrix3 *)jarg1;
13607   arg2 = (Dali::Matrix *)jarg2;
13608   if (!arg2) {
13609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13610     return 0;
13611   }
13612   {
13613     try {
13614       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13615     } catch (std::out_of_range& e) {
13616       {
13617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13618       };
13619     } catch (std::exception& e) {
13620       {
13621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13622       };
13623     } catch (Dali::DaliException e) {
13624       {
13625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13626       };
13627     } catch (...) {
13628       {
13629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13630       };
13631     }
13632   }
13633
13634   jresult = (void *)result;
13635   return jresult;
13636 }
13637
13638
13639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13640   unsigned int jresult ;
13641   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13642   Dali::Matrix3 *arg2 = 0 ;
13643   bool result;
13644
13645   arg1 = (Dali::Matrix3 *)jarg1;
13646   arg2 = (Dali::Matrix3 *)jarg2;
13647   if (!arg2) {
13648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13649     return 0;
13650   }
13651   {
13652     try {
13653       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13654     } catch (std::out_of_range& e) {
13655       {
13656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13657       };
13658     } catch (std::exception& e) {
13659       {
13660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13661       };
13662     } catch (Dali::DaliException e) {
13663       {
13664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13665       };
13666     } catch (...) {
13667       {
13668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13669       };
13670     }
13671   }
13672
13673   jresult = result;
13674   return jresult;
13675 }
13676
13677
13678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13679   unsigned int jresult ;
13680   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13681   Dali::Matrix3 *arg2 = 0 ;
13682   bool result;
13683
13684   arg1 = (Dali::Matrix3 *)jarg1;
13685   arg2 = (Dali::Matrix3 *)jarg2;
13686   if (!arg2) {
13687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13688     return 0;
13689   }
13690   {
13691     try {
13692       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13693     } catch (std::out_of_range& e) {
13694       {
13695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13696       };
13697     } catch (std::exception& e) {
13698       {
13699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13700       };
13701     } catch (Dali::DaliException e) {
13702       {
13703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13704       };
13705     } catch (...) {
13706       {
13707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13708       };
13709     }
13710   }
13711
13712   jresult = result;
13713   return jresult;
13714 }
13715
13716
13717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13718   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13719
13720   arg1 = (Dali::Matrix3 *)jarg1;
13721   {
13722     try {
13723       delete arg1;
13724     } catch (std::out_of_range& e) {
13725       {
13726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13727       };
13728     } catch (std::exception& e) {
13729       {
13730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13731       };
13732     } catch (Dali::DaliException e) {
13733       {
13734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13735       };
13736     } catch (...) {
13737       {
13738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13739       };
13740     }
13741   }
13742
13743 }
13744
13745
13746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13747   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13748
13749   arg1 = (Dali::Matrix3 *)jarg1;
13750   {
13751     try {
13752       (arg1)->SetIdentity();
13753     } catch (std::out_of_range& e) {
13754       {
13755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13756       };
13757     } catch (std::exception& e) {
13758       {
13759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13760       };
13761     } catch (Dali::DaliException e) {
13762       {
13763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13764       };
13765     } catch (...) {
13766       {
13767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13768       };
13769     }
13770   }
13771
13772 }
13773
13774
13775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13776   void * jresult ;
13777   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13778   float *result = 0 ;
13779
13780   arg1 = (Dali::Matrix3 *)jarg1;
13781   {
13782     try {
13783       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13784     } catch (std::out_of_range& e) {
13785       {
13786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13787       };
13788     } catch (std::exception& e) {
13789       {
13790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13791       };
13792     } catch (Dali::DaliException e) {
13793       {
13794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13795       };
13796     } catch (...) {
13797       {
13798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13799       };
13800     }
13801   }
13802
13803   jresult = (void *)result;
13804   return jresult;
13805 }
13806
13807
13808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13809   unsigned int jresult ;
13810   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13811   bool result;
13812
13813   arg1 = (Dali::Matrix3 *)jarg1;
13814   {
13815     try {
13816       result = (bool)(arg1)->Invert();
13817     } catch (std::out_of_range& e) {
13818       {
13819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13820       };
13821     } catch (std::exception& e) {
13822       {
13823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13824       };
13825     } catch (Dali::DaliException e) {
13826       {
13827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13828       };
13829     } catch (...) {
13830       {
13831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13832       };
13833     }
13834   }
13835
13836   jresult = result;
13837   return jresult;
13838 }
13839
13840
13841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13842   unsigned int jresult ;
13843   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13844   bool result;
13845
13846   arg1 = (Dali::Matrix3 *)jarg1;
13847   {
13848     try {
13849       result = (bool)(arg1)->Transpose();
13850     } catch (std::out_of_range& e) {
13851       {
13852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13853       };
13854     } catch (std::exception& e) {
13855       {
13856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13857       };
13858     } catch (Dali::DaliException e) {
13859       {
13860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13861       };
13862     } catch (...) {
13863       {
13864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13865       };
13866     }
13867   }
13868
13869   jresult = result;
13870   return jresult;
13871 }
13872
13873
13874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13875   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13876   float arg2 ;
13877
13878   arg1 = (Dali::Matrix3 *)jarg1;
13879   arg2 = (float)jarg2;
13880   {
13881     try {
13882       (arg1)->Scale(arg2);
13883     } catch (std::out_of_range& e) {
13884       {
13885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13886       };
13887     } catch (std::exception& e) {
13888       {
13889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13890       };
13891     } catch (Dali::DaliException e) {
13892       {
13893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13894       };
13895     } catch (...) {
13896       {
13897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13898       };
13899     }
13900   }
13901
13902 }
13903
13904
13905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13906   float jresult ;
13907   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13908   float result;
13909
13910   arg1 = (Dali::Matrix3 *)jarg1;
13911   {
13912     try {
13913       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13914     } catch (std::out_of_range& e) {
13915       {
13916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13917       };
13918     } catch (std::exception& e) {
13919       {
13920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13921       };
13922     } catch (Dali::DaliException e) {
13923       {
13924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13925       };
13926     } catch (...) {
13927       {
13928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13929       };
13930     }
13931   }
13932
13933   jresult = result;
13934   return jresult;
13935 }
13936
13937
13938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13939   unsigned int jresult ;
13940   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13941   bool result;
13942
13943   arg1 = (Dali::Matrix3 *)jarg1;
13944   {
13945     try {
13946       result = (bool)(arg1)->ScaledInverseTranspose();
13947     } catch (std::out_of_range& e) {
13948       {
13949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13950       };
13951     } catch (std::exception& e) {
13952       {
13953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13954       };
13955     } catch (Dali::DaliException e) {
13956       {
13957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13958       };
13959     } catch (...) {
13960       {
13961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13962       };
13963     }
13964   }
13965
13966   jresult = result;
13967   return jresult;
13968 }
13969
13970
13971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13972   Dali::Matrix3 *arg1 = 0 ;
13973   Dali::Matrix3 *arg2 = 0 ;
13974   Dali::Matrix3 *arg3 = 0 ;
13975
13976   arg1 = (Dali::Matrix3 *)jarg1;
13977   if (!arg1) {
13978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13979     return ;
13980   }
13981   arg2 = (Dali::Matrix3 *)jarg2;
13982   if (!arg2) {
13983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13984     return ;
13985   }
13986   arg3 = (Dali::Matrix3 *)jarg3;
13987   if (!arg3) {
13988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13989     return ;
13990   }
13991   {
13992     try {
13993       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13994     } catch (std::out_of_range& e) {
13995       {
13996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13997       };
13998     } catch (std::exception& e) {
13999       {
14000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14001       };
14002     } catch (Dali::DaliException e) {
14003       {
14004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14005       };
14006     } catch (...) {
14007       {
14008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14009       };
14010     }
14011   }
14012
14013 }
14014
14015
14016 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14017   float jresult ;
14018   float arg1 ;
14019   float arg2 ;
14020   float result;
14021
14022   arg1 = (float)jarg1;
14023   arg2 = (float)jarg2;
14024   {
14025     try {
14026       result = (float)Dali::Random::Range(arg1,arg2);
14027     } catch (std::out_of_range& e) {
14028       {
14029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14030       };
14031     } catch (std::exception& e) {
14032       {
14033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14034       };
14035     } catch (Dali::DaliException e) {
14036       {
14037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14038       };
14039     } catch (...) {
14040       {
14041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14042       };
14043     }
14044   }
14045
14046   jresult = result;
14047   return jresult;
14048 }
14049
14050
14051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14052   void * jresult ;
14053   Dali::Vector4 result;
14054
14055   {
14056     try {
14057       result = Dali::Random::Axis();
14058     } catch (std::out_of_range& e) {
14059       {
14060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14061       };
14062     } catch (std::exception& e) {
14063       {
14064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14065       };
14066     } catch (Dali::DaliException e) {
14067       {
14068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14069       };
14070     } catch (...) {
14071       {
14072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14073       };
14074     }
14075   }
14076
14077   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14078   return jresult;
14079 }
14080
14081
14082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14083   void * jresult ;
14084   Dali::AngleAxis *result = 0 ;
14085
14086   {
14087     try {
14088       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14089     } catch (std::out_of_range& e) {
14090       {
14091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14092       };
14093     } catch (std::exception& e) {
14094       {
14095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14096       };
14097     } catch (Dali::DaliException e) {
14098       {
14099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14100       };
14101     } catch (...) {
14102       {
14103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14104       };
14105     }
14106   }
14107
14108   jresult = (void *)result;
14109   return jresult;
14110 }
14111
14112
14113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14114   void * jresult ;
14115   Dali::Radian arg1 ;
14116   Dali::Vector3 *arg2 = 0 ;
14117   Dali::Radian *argp1 ;
14118   Dali::AngleAxis *result = 0 ;
14119
14120   argp1 = (Dali::Radian *)jarg1;
14121   if (!argp1) {
14122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14123     return 0;
14124   }
14125   arg1 = *argp1;
14126   arg2 = (Dali::Vector3 *)jarg2;
14127   if (!arg2) {
14128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14129     return 0;
14130   }
14131   {
14132     try {
14133       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14134     } catch (std::out_of_range& e) {
14135       {
14136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14137       };
14138     } catch (std::exception& e) {
14139       {
14140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14141       };
14142     } catch (Dali::DaliException e) {
14143       {
14144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14145       };
14146     } catch (...) {
14147       {
14148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14149       };
14150     }
14151   }
14152
14153   jresult = (void *)result;
14154   return jresult;
14155 }
14156
14157
14158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14159   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14160   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14161
14162   arg1 = (Dali::AngleAxis *)jarg1;
14163   arg2 = (Dali::Radian *)jarg2;
14164   if (arg1) (arg1)->angle = *arg2;
14165 }
14166
14167
14168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14169   void * jresult ;
14170   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14171   Dali::Radian *result = 0 ;
14172
14173   arg1 = (Dali::AngleAxis *)jarg1;
14174   result = (Dali::Radian *)& ((arg1)->angle);
14175   jresult = (void *)result;
14176   return jresult;
14177 }
14178
14179
14180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14181   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14182   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14183
14184   arg1 = (Dali::AngleAxis *)jarg1;
14185   arg2 = (Dali::Vector3 *)jarg2;
14186   if (arg1) (arg1)->axis = *arg2;
14187 }
14188
14189
14190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14191   void * jresult ;
14192   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14193   Dali::Vector3 *result = 0 ;
14194
14195   arg1 = (Dali::AngleAxis *)jarg1;
14196   result = (Dali::Vector3 *)& ((arg1)->axis);
14197   jresult = (void *)result;
14198   return jresult;
14199 }
14200
14201
14202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14203   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14204
14205   arg1 = (Dali::AngleAxis *)jarg1;
14206   {
14207     try {
14208       delete arg1;
14209     } catch (std::out_of_range& e) {
14210       {
14211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14212       };
14213     } catch (std::exception& e) {
14214       {
14215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14216       };
14217     } catch (Dali::DaliException e) {
14218       {
14219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14220       };
14221     } catch (...) {
14222       {
14223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14224       };
14225     }
14226   }
14227
14228 }
14229
14230
14231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14232   unsigned int jresult ;
14233   Dali::AngleAxis *arg1 = 0 ;
14234   Dali::AngleAxis *arg2 = 0 ;
14235   bool result;
14236
14237   arg1 = (Dali::AngleAxis *)jarg1;
14238   if (!arg1) {
14239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14240     return 0;
14241   }
14242   arg2 = (Dali::AngleAxis *)jarg2;
14243   if (!arg2) {
14244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14245     return 0;
14246   }
14247   {
14248     try {
14249       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14250     } catch (std::out_of_range& e) {
14251       {
14252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14253       };
14254     } catch (std::exception& e) {
14255       {
14256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14257       };
14258     } catch (Dali::DaliException e) {
14259       {
14260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14261       };
14262     } catch (...) {
14263       {
14264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14265       };
14266     }
14267   }
14268
14269   jresult = result;
14270   return jresult;
14271 }
14272
14273
14274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14275   unsigned int jresult ;
14276   unsigned int arg1 ;
14277   unsigned int result;
14278
14279   arg1 = (unsigned int)jarg1;
14280   {
14281     try {
14282       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14283     } catch (std::out_of_range& e) {
14284       {
14285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14286       };
14287     } catch (std::exception& e) {
14288       {
14289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14290       };
14291     } catch (Dali::DaliException e) {
14292       {
14293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14294       };
14295     } catch (...) {
14296       {
14297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14298       };
14299     }
14300   }
14301
14302   jresult = result;
14303   return jresult;
14304 }
14305
14306
14307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14308   unsigned int jresult ;
14309   unsigned int arg1 ;
14310   bool result;
14311
14312   arg1 = (unsigned int)jarg1;
14313   {
14314     try {
14315       result = (bool)Dali::IsPowerOfTwo(arg1);
14316     } catch (std::out_of_range& e) {
14317       {
14318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14319       };
14320     } catch (std::exception& e) {
14321       {
14322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14323       };
14324     } catch (Dali::DaliException e) {
14325       {
14326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14327       };
14328     } catch (...) {
14329       {
14330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14331       };
14332     }
14333   }
14334
14335   jresult = result;
14336   return jresult;
14337 }
14338
14339
14340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14341   float jresult ;
14342   float arg1 ;
14343   float arg2 ;
14344   float result;
14345
14346   arg1 = (float)jarg1;
14347   arg2 = (float)jarg2;
14348   {
14349     try {
14350       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14351     } catch (std::out_of_range& e) {
14352       {
14353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14354       };
14355     } catch (std::exception& e) {
14356       {
14357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14358       };
14359     } catch (Dali::DaliException e) {
14360       {
14361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14362       };
14363     } catch (...) {
14364       {
14365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14366       };
14367     }
14368   }
14369
14370   jresult = result;
14371   return jresult;
14372 }
14373
14374
14375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14376   unsigned int jresult ;
14377   float arg1 ;
14378   bool result;
14379
14380   arg1 = (float)jarg1;
14381   {
14382     try {
14383       result = (bool)Dali::EqualsZero(arg1);
14384     } catch (std::out_of_range& e) {
14385       {
14386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14387       };
14388     } catch (std::exception& e) {
14389       {
14390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14391       };
14392     } catch (Dali::DaliException e) {
14393       {
14394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14395       };
14396     } catch (...) {
14397       {
14398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14399       };
14400     }
14401   }
14402
14403   jresult = result;
14404   return jresult;
14405 }
14406
14407
14408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14409   unsigned int jresult ;
14410   float arg1 ;
14411   float arg2 ;
14412   bool result;
14413
14414   arg1 = (float)jarg1;
14415   arg2 = (float)jarg2;
14416   {
14417     try {
14418       result = (bool)Dali::Equals(arg1,arg2);
14419     } catch (std::out_of_range& e) {
14420       {
14421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14422       };
14423     } catch (std::exception& e) {
14424       {
14425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14426       };
14427     } catch (Dali::DaliException e) {
14428       {
14429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14430       };
14431     } catch (...) {
14432       {
14433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14434       };
14435     }
14436   }
14437
14438   jresult = result;
14439   return jresult;
14440 }
14441
14442
14443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14444   unsigned int jresult ;
14445   float arg1 ;
14446   float arg2 ;
14447   float arg3 ;
14448   bool result;
14449
14450   arg1 = (float)jarg1;
14451   arg2 = (float)jarg2;
14452   arg3 = (float)jarg3;
14453   {
14454     try {
14455       result = (bool)Dali::Equals(arg1,arg2,arg3);
14456     } catch (std::out_of_range& e) {
14457       {
14458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14459       };
14460     } catch (std::exception& e) {
14461       {
14462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14463       };
14464     } catch (Dali::DaliException e) {
14465       {
14466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14467       };
14468     } catch (...) {
14469       {
14470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14471       };
14472     }
14473   }
14474
14475   jresult = result;
14476   return jresult;
14477 }
14478
14479
14480 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14481   float jresult ;
14482   float arg1 ;
14483   int arg2 ;
14484   float result;
14485
14486   arg1 = (float)jarg1;
14487   arg2 = (int)jarg2;
14488   {
14489     try {
14490       result = (float)Dali::Round(arg1,arg2);
14491     } catch (std::out_of_range& e) {
14492       {
14493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14494       };
14495     } catch (std::exception& e) {
14496       {
14497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14498       };
14499     } catch (Dali::DaliException e) {
14500       {
14501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14502       };
14503     } catch (...) {
14504       {
14505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14506       };
14507     }
14508   }
14509
14510   jresult = result;
14511   return jresult;
14512 }
14513
14514
14515 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14516   float jresult ;
14517   float arg1 ;
14518   float arg2 ;
14519   float arg3 ;
14520   float result;
14521
14522   arg1 = (float)jarg1;
14523   arg2 = (float)jarg2;
14524   arg3 = (float)jarg3;
14525   {
14526     try {
14527       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14528     } catch (std::out_of_range& e) {
14529       {
14530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14531       };
14532     } catch (std::exception& e) {
14533       {
14534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14535       };
14536     } catch (Dali::DaliException e) {
14537       {
14538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14539       };
14540     } catch (...) {
14541       {
14542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14543       };
14544     }
14545   }
14546
14547   jresult = result;
14548   return jresult;
14549 }
14550
14551
14552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14553   float jresult ;
14554   float arg1 ;
14555   float arg2 ;
14556   float arg3 ;
14557   float arg4 ;
14558   float result;
14559
14560   arg1 = (float)jarg1;
14561   arg2 = (float)jarg2;
14562   arg3 = (float)jarg3;
14563   arg4 = (float)jarg4;
14564   {
14565     try {
14566       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14567     } catch (std::out_of_range& e) {
14568       {
14569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14570       };
14571     } catch (std::exception& e) {
14572       {
14573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14574       };
14575     } catch (Dali::DaliException e) {
14576       {
14577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14578       };
14579     } catch (...) {
14580       {
14581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14582       };
14583     }
14584   }
14585
14586   jresult = result;
14587   return jresult;
14588 }
14589
14590
14591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14592   int jresult ;
14593   int result;
14594
14595   result = (int)(int)Dali::Property::INVALID_INDEX;
14596   jresult = result;
14597   return jresult;
14598 }
14599
14600
14601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14602   int jresult ;
14603   int result;
14604
14605   result = (int)(int)Dali::Property::INVALID_KEY;
14606   jresult = result;
14607   return jresult;
14608 }
14609
14610
14611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14612   int jresult ;
14613   int result;
14614
14615   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14616   jresult = result;
14617   return jresult;
14618 }
14619
14620
14621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14622   void * jresult ;
14623   Dali::Handle *arg1 = 0 ;
14624   Dali::Property::Index arg2 ;
14625   Dali::Property *result = 0 ;
14626
14627   arg1 = (Dali::Handle *)jarg1;
14628   if (!arg1) {
14629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14630     return 0;
14631   }
14632   arg2 = (Dali::Property::Index)jarg2;
14633   {
14634     try {
14635       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14636     } catch (std::out_of_range& e) {
14637       {
14638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14639       };
14640     } catch (std::exception& e) {
14641       {
14642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14643       };
14644     } catch (Dali::DaliException e) {
14645       {
14646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14647       };
14648     } catch (...) {
14649       {
14650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14651       };
14652     }
14653   }
14654
14655   jresult = (void *)result;
14656   return jresult;
14657 }
14658
14659
14660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14661   void * jresult ;
14662   Dali::Handle *arg1 = 0 ;
14663   Dali::Property::Index arg2 ;
14664   int arg3 ;
14665   Dali::Property *result = 0 ;
14666
14667   arg1 = (Dali::Handle *)jarg1;
14668   if (!arg1) {
14669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14670     return 0;
14671   }
14672   arg2 = (Dali::Property::Index)jarg2;
14673   arg3 = (int)jarg3;
14674   {
14675     try {
14676       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14677     } catch (std::out_of_range& e) {
14678       {
14679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14680       };
14681     } catch (std::exception& e) {
14682       {
14683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14684       };
14685     } catch (Dali::DaliException e) {
14686       {
14687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14688       };
14689     } catch (...) {
14690       {
14691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14692       };
14693     }
14694   }
14695
14696   jresult = (void *)result;
14697   return jresult;
14698 }
14699
14700
14701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14702   void * jresult ;
14703   Dali::Handle *arg1 = 0 ;
14704   std::string *arg2 = 0 ;
14705   Dali::Property *result = 0 ;
14706
14707   arg1 = (Dali::Handle *)jarg1;
14708   if (!arg1) {
14709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14710     return 0;
14711   }
14712   if (!jarg2) {
14713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14714     return 0;
14715   }
14716   std::string arg2_str(jarg2);
14717   arg2 = &arg2_str;
14718   {
14719     try {
14720       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14721     } catch (std::out_of_range& e) {
14722       {
14723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14724       };
14725     } catch (std::exception& e) {
14726       {
14727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14728       };
14729     } catch (Dali::DaliException e) {
14730       {
14731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14732       };
14733     } catch (...) {
14734       {
14735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14736       };
14737     }
14738   }
14739
14740   jresult = (void *)result;
14741
14742   //argout typemap for const std::string&
14743
14744   return jresult;
14745 }
14746
14747
14748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14749   void * jresult ;
14750   Dali::Handle *arg1 = 0 ;
14751   std::string *arg2 = 0 ;
14752   int arg3 ;
14753   Dali::Property *result = 0 ;
14754
14755   arg1 = (Dali::Handle *)jarg1;
14756   if (!arg1) {
14757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14758     return 0;
14759   }
14760   if (!jarg2) {
14761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14762     return 0;
14763   }
14764   std::string arg2_str(jarg2);
14765   arg2 = &arg2_str;
14766   arg3 = (int)jarg3;
14767   {
14768     try {
14769       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14770     } catch (std::out_of_range& e) {
14771       {
14772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14773       };
14774     } catch (std::exception& e) {
14775       {
14776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14777       };
14778     } catch (Dali::DaliException e) {
14779       {
14780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14781       };
14782     } catch (...) {
14783       {
14784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14785       };
14786     }
14787   }
14788
14789   jresult = (void *)result;
14790
14791   //argout typemap for const std::string&
14792
14793   return jresult;
14794 }
14795
14796
14797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14798   Dali::Property *arg1 = (Dali::Property *) 0 ;
14799
14800   arg1 = (Dali::Property *)jarg1;
14801   {
14802     try {
14803       delete arg1;
14804     } catch (std::out_of_range& e) {
14805       {
14806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14807       };
14808     } catch (std::exception& e) {
14809       {
14810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14811       };
14812     } catch (Dali::DaliException e) {
14813       {
14814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14815       };
14816     } catch (...) {
14817       {
14818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14819       };
14820     }
14821   }
14822
14823 }
14824
14825
14826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14827   Dali::Property *arg1 = (Dali::Property *) 0 ;
14828   Dali::Handle *arg2 = 0 ;
14829
14830   arg1 = (Dali::Property *)jarg1;
14831   arg2 = (Dali::Handle *)jarg2;
14832   if (!arg2) {
14833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14834     return ;
14835   }
14836   if (arg1) (arg1)->object = *arg2;
14837 }
14838
14839
14840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14841   void * jresult ;
14842   Dali::Property *arg1 = (Dali::Property *) 0 ;
14843   Dali::Handle *result = 0 ;
14844
14845   arg1 = (Dali::Property *)jarg1;
14846   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14847   jresult = (void *)result;
14848   return jresult;
14849 }
14850
14851
14852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14853   Dali::Property *arg1 = (Dali::Property *) 0 ;
14854   Dali::Property::Index arg2 ;
14855
14856   arg1 = (Dali::Property *)jarg1;
14857   arg2 = (Dali::Property::Index)jarg2;
14858   if (arg1) (arg1)->propertyIndex = arg2;
14859 }
14860
14861
14862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14863   int jresult ;
14864   Dali::Property *arg1 = (Dali::Property *) 0 ;
14865   Dali::Property::Index result;
14866
14867   arg1 = (Dali::Property *)jarg1;
14868   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14869   jresult = result;
14870   return jresult;
14871 }
14872
14873
14874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14875   Dali::Property *arg1 = (Dali::Property *) 0 ;
14876   int arg2 ;
14877
14878   arg1 = (Dali::Property *)jarg1;
14879   arg2 = (int)jarg2;
14880   if (arg1) (arg1)->componentIndex = arg2;
14881 }
14882
14883
14884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14885   int jresult ;
14886   Dali::Property *arg1 = (Dali::Property *) 0 ;
14887   int result;
14888
14889   arg1 = (Dali::Property *)jarg1;
14890   result = (int) ((arg1)->componentIndex);
14891   jresult = result;
14892   return jresult;
14893 }
14894
14895
14896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14897   void * jresult ;
14898   Dali::Property::Array *result = 0 ;
14899
14900   {
14901     try {
14902       result = (Dali::Property::Array *)new Dali::Property::Array();
14903     } catch (std::out_of_range& e) {
14904       {
14905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14906       };
14907     } catch (std::exception& e) {
14908       {
14909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14910       };
14911     } catch (Dali::DaliException e) {
14912       {
14913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14914       };
14915     } catch (...) {
14916       {
14917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14918       };
14919     }
14920   }
14921
14922   jresult = (void *)result;
14923   return jresult;
14924 }
14925
14926
14927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14928   void * jresult ;
14929   Dali::Property::Array *arg1 = 0 ;
14930   Dali::Property::Array *result = 0 ;
14931
14932   arg1 = (Dali::Property::Array *)jarg1;
14933   if (!arg1) {
14934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14935     return 0;
14936   }
14937   {
14938     try {
14939       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14940     } catch (std::out_of_range& e) {
14941       {
14942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14943       };
14944     } catch (std::exception& e) {
14945       {
14946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14947       };
14948     } catch (Dali::DaliException e) {
14949       {
14950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14951       };
14952     } catch (...) {
14953       {
14954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14955       };
14956     }
14957   }
14958
14959   jresult = (void *)result;
14960   return jresult;
14961 }
14962
14963
14964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14965   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14966
14967   arg1 = (Dali::Property::Array *)jarg1;
14968   {
14969     try {
14970       delete arg1;
14971     } catch (std::out_of_range& e) {
14972       {
14973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14974       };
14975     } catch (std::exception& e) {
14976       {
14977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14978       };
14979     } catch (Dali::DaliException e) {
14980       {
14981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14982       };
14983     } catch (...) {
14984       {
14985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14986       };
14987     }
14988   }
14989
14990 }
14991
14992
14993 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14994   unsigned long jresult ;
14995   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14996   Dali::Property::Array::SizeType result;
14997
14998   arg1 = (Dali::Property::Array *)jarg1;
14999   {
15000     try {
15001       result = ((Dali::Property::Array const *)arg1)->Size();
15002     } catch (std::out_of_range& e) {
15003       {
15004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15005       };
15006     } catch (std::exception& e) {
15007       {
15008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15009       };
15010     } catch (Dali::DaliException e) {
15011       {
15012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15013       };
15014     } catch (...) {
15015       {
15016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15017       };
15018     }
15019   }
15020
15021   jresult = (unsigned long)result;
15022   return jresult;
15023 }
15024
15025
15026 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15027   unsigned long jresult ;
15028   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15029   Dali::Property::Array::SizeType result;
15030
15031   arg1 = (Dali::Property::Array *)jarg1;
15032   {
15033     try {
15034       result = ((Dali::Property::Array const *)arg1)->Count();
15035     } catch (std::out_of_range& e) {
15036       {
15037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15038       };
15039     } catch (std::exception& e) {
15040       {
15041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15042       };
15043     } catch (Dali::DaliException e) {
15044       {
15045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15046       };
15047     } catch (...) {
15048       {
15049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15050       };
15051     }
15052   }
15053
15054   jresult = (unsigned long)result;
15055   return jresult;
15056 }
15057
15058
15059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15060   unsigned int jresult ;
15061   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15062   bool result;
15063
15064   arg1 = (Dali::Property::Array *)jarg1;
15065   {
15066     try {
15067       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15068     } catch (std::out_of_range& e) {
15069       {
15070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15071       };
15072     } catch (std::exception& e) {
15073       {
15074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15075       };
15076     } catch (Dali::DaliException e) {
15077       {
15078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15079       };
15080     } catch (...) {
15081       {
15082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15083       };
15084     }
15085   }
15086
15087   jresult = result;
15088   return jresult;
15089 }
15090
15091
15092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15093   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15094
15095   arg1 = (Dali::Property::Array *)jarg1;
15096   {
15097     try {
15098       (arg1)->Clear();
15099     } catch (std::out_of_range& e) {
15100       {
15101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15102       };
15103     } catch (std::exception& e) {
15104       {
15105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15106       };
15107     } catch (Dali::DaliException e) {
15108       {
15109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15110       };
15111     } catch (...) {
15112       {
15113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15114       };
15115     }
15116   }
15117
15118 }
15119
15120
15121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15122   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15123   Dali::Property::Array::SizeType arg2 ;
15124
15125   arg1 = (Dali::Property::Array *)jarg1;
15126   arg2 = (Dali::Property::Array::SizeType)jarg2;
15127   {
15128     try {
15129       (arg1)->Reserve(arg2);
15130     } catch (std::out_of_range& e) {
15131       {
15132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15133       };
15134     } catch (std::exception& e) {
15135       {
15136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15137       };
15138     } catch (Dali::DaliException e) {
15139       {
15140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15141       };
15142     } catch (...) {
15143       {
15144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15145       };
15146     }
15147   }
15148
15149 }
15150
15151
15152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15153   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15154   Dali::Property::Array::SizeType arg2 ;
15155
15156   arg1 = (Dali::Property::Array *)jarg1;
15157   arg2 = (Dali::Property::Array::SizeType)jarg2;
15158   {
15159     try {
15160       (arg1)->Resize(arg2);
15161     } catch (std::out_of_range& e) {
15162       {
15163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15164       };
15165     } catch (std::exception& e) {
15166       {
15167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15168       };
15169     } catch (Dali::DaliException e) {
15170       {
15171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15172       };
15173     } catch (...) {
15174       {
15175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15176       };
15177     }
15178   }
15179
15180 }
15181
15182
15183 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15184   unsigned long jresult ;
15185   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15186   Dali::Property::Array::SizeType result;
15187
15188   arg1 = (Dali::Property::Array *)jarg1;
15189   {
15190     try {
15191       result = (arg1)->Capacity();
15192     } catch (std::out_of_range& e) {
15193       {
15194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15195       };
15196     } catch (std::exception& e) {
15197       {
15198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15199       };
15200     } catch (Dali::DaliException e) {
15201       {
15202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15203       };
15204     } catch (...) {
15205       {
15206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15207       };
15208     }
15209   }
15210
15211   jresult = (unsigned long)result;
15212   return jresult;
15213 }
15214
15215
15216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15217   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15218   Dali::Property::Value *arg2 = 0 ;
15219
15220   arg1 = (Dali::Property::Array *)jarg1;
15221   arg2 = (Dali::Property::Value *)jarg2;
15222   if (!arg2) {
15223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15224     return ;
15225   }
15226   {
15227     try {
15228       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15229     } catch (std::out_of_range& e) {
15230       {
15231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15232       };
15233     } catch (std::exception& e) {
15234       {
15235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15236       };
15237     } catch (Dali::DaliException e) {
15238       {
15239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15240       };
15241     } catch (...) {
15242       {
15243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15244       };
15245     }
15246   }
15247
15248 }
15249
15250
15251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15252   void * jresult ;
15253   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15254   Dali::Property::Value *arg2 = 0 ;
15255   Dali::Property::Array *result = 0 ;
15256
15257   arg1 = (Dali::Property::Array *)jarg1;
15258   arg2 = (Dali::Property::Value *)jarg2;
15259   if (!arg2) {
15260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15261     return 0;
15262   }
15263   {
15264     try {
15265       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15266     } catch (std::out_of_range& e) {
15267       {
15268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15269       };
15270     } catch (std::exception& e) {
15271       {
15272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15273       };
15274     } catch (Dali::DaliException e) {
15275       {
15276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15277       };
15278     } catch (...) {
15279       {
15280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15281       };
15282     }
15283   }
15284
15285   jresult = (void *)result;
15286   return jresult;
15287 }
15288
15289
15290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15291   void * jresult ;
15292   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15293   Dali::Property::Array::SizeType arg2 ;
15294   Dali::Property::Value *result = 0 ;
15295
15296   arg1 = (Dali::Property::Array *)jarg1;
15297   arg2 = (Dali::Property::Array::SizeType)jarg2;
15298   {
15299     try {
15300       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15301     } catch (std::out_of_range& e) {
15302       {
15303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15304       };
15305     } catch (std::exception& e) {
15306       {
15307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15308       };
15309     } catch (Dali::DaliException e) {
15310       {
15311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15312       };
15313     } catch (...) {
15314       {
15315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15316       };
15317     }
15318   }
15319
15320   jresult = (void *)result;
15321   return jresult;
15322 }
15323
15324
15325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15326   void * jresult ;
15327   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15328   Dali::Property::Array::SizeType arg2 ;
15329   Dali::Property::Value *result = 0 ;
15330
15331   arg1 = (Dali::Property::Array *)jarg1;
15332   arg2 = (Dali::Property::Array::SizeType)jarg2;
15333   {
15334     try {
15335       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15336     } catch (std::out_of_range& e) {
15337       {
15338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15339       };
15340     } catch (std::exception& e) {
15341       {
15342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15343       };
15344     } catch (Dali::DaliException e) {
15345       {
15346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15347       };
15348     } catch (...) {
15349       {
15350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15351       };
15352     }
15353   }
15354
15355   jresult = (void *)result;
15356   return jresult;
15357 }
15358
15359
15360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15361   void * jresult ;
15362   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15363   Dali::Property::Array *arg2 = 0 ;
15364   Dali::Property::Array *result = 0 ;
15365
15366   arg1 = (Dali::Property::Array *)jarg1;
15367   arg2 = (Dali::Property::Array *)jarg2;
15368   if (!arg2) {
15369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15370     return 0;
15371   }
15372   {
15373     try {
15374       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15375     } catch (std::out_of_range& e) {
15376       {
15377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15378       };
15379     } catch (std::exception& e) {
15380       {
15381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15382       };
15383     } catch (Dali::DaliException e) {
15384       {
15385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15386       };
15387     } catch (...) {
15388       {
15389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15390       };
15391     }
15392   }
15393
15394   jresult = (void *)result;
15395   return jresult;
15396 }
15397
15398
15399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15400   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15401   enum Dali::Property::Key::Type arg2 ;
15402
15403   arg1 = (Dali::Property::Key *)jarg1;
15404   arg2 = (enum Dali::Property::Key::Type)jarg2;
15405   if (arg1) (arg1)->type = arg2;
15406 }
15407
15408
15409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15410   int jresult ;
15411   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15412   enum Dali::Property::Key::Type result;
15413
15414   arg1 = (Dali::Property::Key *)jarg1;
15415   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15416   jresult = (int)result;
15417   return jresult;
15418 }
15419
15420
15421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15422   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15423   Dali::Property::Index arg2 ;
15424
15425   arg1 = (Dali::Property::Key *)jarg1;
15426   arg2 = (Dali::Property::Index)jarg2;
15427   if (arg1) (arg1)->indexKey = arg2;
15428 }
15429
15430
15431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15432   int jresult ;
15433   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15434   Dali::Property::Index result;
15435
15436   arg1 = (Dali::Property::Key *)jarg1;
15437   result = (Dali::Property::Index) ((arg1)->indexKey);
15438   jresult = result;
15439   return jresult;
15440 }
15441
15442
15443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15444   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15445   std::string *arg2 = 0 ;
15446
15447   arg1 = (Dali::Property::Key *)jarg1;
15448   if (!jarg2) {
15449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15450     return ;
15451   }
15452   std::string arg2_str(jarg2);
15453   arg2 = &arg2_str;
15454   if (arg1) (arg1)->stringKey = *arg2;
15455
15456   //argout typemap for const std::string&
15457
15458 }
15459
15460
15461 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15462   char * jresult ;
15463   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15464   std::string *result = 0 ;
15465
15466   arg1 = (Dali::Property::Key *)jarg1;
15467   result = (std::string *) & ((arg1)->stringKey);
15468   jresult = SWIG_csharp_string_callback(result->c_str());
15469   return jresult;
15470 }
15471
15472
15473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15474   void * jresult ;
15475   std::string *arg1 = 0 ;
15476   Dali::Property::Key *result = 0 ;
15477
15478   if (!jarg1) {
15479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15480     return 0;
15481   }
15482   std::string arg1_str(jarg1);
15483   arg1 = &arg1_str;
15484   {
15485     try {
15486       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15487     } catch (std::out_of_range& e) {
15488       {
15489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15490       };
15491     } catch (std::exception& e) {
15492       {
15493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15494       };
15495     } catch (Dali::DaliException e) {
15496       {
15497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15498       };
15499     } catch (...) {
15500       {
15501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15502       };
15503     }
15504   }
15505
15506   jresult = (void *)result;
15507
15508   //argout typemap for const std::string&
15509
15510   return jresult;
15511 }
15512
15513
15514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15515   void * jresult ;
15516   Dali::Property::Index arg1 ;
15517   Dali::Property::Key *result = 0 ;
15518
15519   arg1 = (Dali::Property::Index)jarg1;
15520   {
15521     try {
15522       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15523     } catch (std::out_of_range& e) {
15524       {
15525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15526       };
15527     } catch (std::exception& e) {
15528       {
15529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15530       };
15531     } catch (Dali::DaliException e) {
15532       {
15533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15534       };
15535     } catch (...) {
15536       {
15537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15538       };
15539     }
15540   }
15541
15542   jresult = (void *)result;
15543   return jresult;
15544 }
15545
15546
15547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15548   unsigned int jresult ;
15549   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15550   std::string *arg2 = 0 ;
15551   bool result;
15552
15553   arg1 = (Dali::Property::Key *)jarg1;
15554   if (!jarg2) {
15555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15556     return 0;
15557   }
15558   std::string arg2_str(jarg2);
15559   arg2 = &arg2_str;
15560   {
15561     try {
15562       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15563     } catch (std::out_of_range& e) {
15564       {
15565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15566       };
15567     } catch (std::exception& e) {
15568       {
15569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15570       };
15571     } catch (Dali::DaliException e) {
15572       {
15573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15574       };
15575     } catch (...) {
15576       {
15577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15578       };
15579     }
15580   }
15581
15582   jresult = result;
15583
15584   //argout typemap for const std::string&
15585
15586   return jresult;
15587 }
15588
15589
15590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15591   unsigned int jresult ;
15592   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15593   Dali::Property::Index arg2 ;
15594   bool result;
15595
15596   arg1 = (Dali::Property::Key *)jarg1;
15597   arg2 = (Dali::Property::Index)jarg2;
15598   {
15599     try {
15600       result = (bool)(arg1)->operator ==(arg2);
15601     } catch (std::out_of_range& e) {
15602       {
15603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15604       };
15605     } catch (std::exception& e) {
15606       {
15607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15608       };
15609     } catch (Dali::DaliException e) {
15610       {
15611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15612       };
15613     } catch (...) {
15614       {
15615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15616       };
15617     }
15618   }
15619
15620   jresult = result;
15621   return jresult;
15622 }
15623
15624
15625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15626   unsigned int jresult ;
15627   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15628   Dali::Property::Key *arg2 = 0 ;
15629   bool result;
15630
15631   arg1 = (Dali::Property::Key *)jarg1;
15632   arg2 = (Dali::Property::Key *)jarg2;
15633   if (!arg2) {
15634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15635     return 0;
15636   }
15637   {
15638     try {
15639       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15640     } catch (std::out_of_range& e) {
15641       {
15642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15643       };
15644     } catch (std::exception& e) {
15645       {
15646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15647       };
15648     } catch (Dali::DaliException e) {
15649       {
15650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15651       };
15652     } catch (...) {
15653       {
15654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15655       };
15656     }
15657   }
15658
15659   jresult = result;
15660   return jresult;
15661 }
15662
15663
15664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15665   unsigned int jresult ;
15666   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15667   std::string *arg2 = 0 ;
15668   bool result;
15669
15670   arg1 = (Dali::Property::Key *)jarg1;
15671   if (!jarg2) {
15672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15673     return 0;
15674   }
15675   std::string arg2_str(jarg2);
15676   arg2 = &arg2_str;
15677   {
15678     try {
15679       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15680     } catch (std::out_of_range& e) {
15681       {
15682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15683       };
15684     } catch (std::exception& e) {
15685       {
15686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15687       };
15688     } catch (Dali::DaliException e) {
15689       {
15690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15691       };
15692     } catch (...) {
15693       {
15694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15695       };
15696     }
15697   }
15698
15699   jresult = result;
15700
15701   //argout typemap for const std::string&
15702
15703   return jresult;
15704 }
15705
15706
15707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15708   unsigned int jresult ;
15709   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15710   Dali::Property::Index arg2 ;
15711   bool result;
15712
15713   arg1 = (Dali::Property::Key *)jarg1;
15714   arg2 = (Dali::Property::Index)jarg2;
15715   {
15716     try {
15717       result = (bool)(arg1)->operator !=(arg2);
15718     } catch (std::out_of_range& e) {
15719       {
15720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15721       };
15722     } catch (std::exception& e) {
15723       {
15724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15725       };
15726     } catch (Dali::DaliException e) {
15727       {
15728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15729       };
15730     } catch (...) {
15731       {
15732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15733       };
15734     }
15735   }
15736
15737   jresult = result;
15738   return jresult;
15739 }
15740
15741
15742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15743   unsigned int jresult ;
15744   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15745   Dali::Property::Key *arg2 = 0 ;
15746   bool result;
15747
15748   arg1 = (Dali::Property::Key *)jarg1;
15749   arg2 = (Dali::Property::Key *)jarg2;
15750   if (!arg2) {
15751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15752     return 0;
15753   }
15754   {
15755     try {
15756       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15757     } catch (std::out_of_range& e) {
15758       {
15759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15760       };
15761     } catch (std::exception& e) {
15762       {
15763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15764       };
15765     } catch (Dali::DaliException e) {
15766       {
15767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15768       };
15769     } catch (...) {
15770       {
15771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15772       };
15773     }
15774   }
15775
15776   jresult = result;
15777   return jresult;
15778 }
15779
15780
15781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15782   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15783
15784   arg1 = (Dali::Property::Key *)jarg1;
15785   {
15786     try {
15787       delete arg1;
15788     } catch (std::out_of_range& e) {
15789       {
15790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15791       };
15792     } catch (std::exception& e) {
15793       {
15794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15795       };
15796     } catch (Dali::DaliException e) {
15797       {
15798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15799       };
15800     } catch (...) {
15801       {
15802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15803       };
15804     }
15805   }
15806
15807 }
15808
15809
15810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15811   void * jresult ;
15812   Dali::Property::Map *result = 0 ;
15813
15814   {
15815     try {
15816       result = (Dali::Property::Map *)new Dali::Property::Map();
15817     } catch (std::out_of_range& e) {
15818       {
15819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15820       };
15821     } catch (std::exception& e) {
15822       {
15823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15824       };
15825     } catch (Dali::DaliException e) {
15826       {
15827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15828       };
15829     } catch (...) {
15830       {
15831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15832       };
15833     }
15834   }
15835
15836   jresult = (void *)result;
15837   return jresult;
15838 }
15839
15840
15841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15842   void * jresult ;
15843   Dali::Property::Map *arg1 = 0 ;
15844   Dali::Property::Map *result = 0 ;
15845
15846   arg1 = (Dali::Property::Map *)jarg1;
15847   if (!arg1) {
15848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15849     return 0;
15850   }
15851   {
15852     try {
15853       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15854     } catch (std::out_of_range& e) {
15855       {
15856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15857       };
15858     } catch (std::exception& e) {
15859       {
15860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15861       };
15862     } catch (Dali::DaliException e) {
15863       {
15864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15865       };
15866     } catch (...) {
15867       {
15868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15869       };
15870     }
15871   }
15872
15873   jresult = (void *)result;
15874   return jresult;
15875 }
15876
15877
15878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15879   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15880
15881   arg1 = (Dali::Property::Map *)jarg1;
15882   {
15883     try {
15884       delete arg1;
15885     } catch (std::out_of_range& e) {
15886       {
15887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15888       };
15889     } catch (std::exception& e) {
15890       {
15891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15892       };
15893     } catch (Dali::DaliException e) {
15894       {
15895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15896       };
15897     } catch (...) {
15898       {
15899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15900       };
15901     }
15902   }
15903
15904 }
15905
15906
15907 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15908   unsigned long jresult ;
15909   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15910   Dali::Property::Map::SizeType result;
15911
15912   arg1 = (Dali::Property::Map *)jarg1;
15913   {
15914     try {
15915       result = ((Dali::Property::Map const *)arg1)->Count();
15916     } catch (std::out_of_range& e) {
15917       {
15918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15919       };
15920     } catch (std::exception& e) {
15921       {
15922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15923       };
15924     } catch (Dali::DaliException e) {
15925       {
15926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15927       };
15928     } catch (...) {
15929       {
15930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15931       };
15932     }
15933   }
15934
15935   jresult = (unsigned long)result;
15936   return jresult;
15937 }
15938
15939
15940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15941   unsigned int jresult ;
15942   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15943   bool result;
15944
15945   arg1 = (Dali::Property::Map *)jarg1;
15946   {
15947     try {
15948       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15949     } catch (std::out_of_range& e) {
15950       {
15951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15952       };
15953     } catch (std::exception& e) {
15954       {
15955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15956       };
15957     } catch (Dali::DaliException e) {
15958       {
15959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15960       };
15961     } catch (...) {
15962       {
15963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15964       };
15965     }
15966   }
15967
15968   jresult = result;
15969   return jresult;
15970 }
15971
15972
15973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15974   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15975   char *arg2 = (char *) 0 ;
15976   Dali::Property::Value *arg3 = 0 ;
15977
15978   arg1 = (Dali::Property::Map *)jarg1;
15979   arg2 = (char *)jarg2;
15980   arg3 = (Dali::Property::Value *)jarg3;
15981   if (!arg3) {
15982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15983     return ;
15984   }
15985   {
15986     try {
15987       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15988     } catch (std::out_of_range& e) {
15989       {
15990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15991       };
15992     } catch (std::exception& e) {
15993       {
15994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15995       };
15996     } catch (Dali::DaliException e) {
15997       {
15998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15999       };
16000     } catch (...) {
16001       {
16002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16003       };
16004     }
16005   }
16006
16007 }
16008
16009
16010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16011   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16012   Dali::Property::Index arg2 ;
16013   Dali::Property::Value *arg3 = 0 ;
16014
16015   arg1 = (Dali::Property::Map *)jarg1;
16016   arg2 = (Dali::Property::Index)jarg2;
16017   arg3 = (Dali::Property::Value *)jarg3;
16018   if (!arg3) {
16019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16020     return ;
16021   }
16022   {
16023     try {
16024       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16025     } catch (std::out_of_range& e) {
16026       {
16027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16028       };
16029     } catch (std::exception& e) {
16030       {
16031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16032       };
16033     } catch (Dali::DaliException e) {
16034       {
16035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16036       };
16037     } catch (...) {
16038       {
16039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16040       };
16041     }
16042   }
16043
16044 }
16045
16046
16047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16048   void * jresult ;
16049   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16050   char *arg2 = (char *) 0 ;
16051   Dali::Property::Value *arg3 = 0 ;
16052   Dali::Property::Map *result = 0 ;
16053
16054   arg1 = (Dali::Property::Map *)jarg1;
16055   arg2 = (char *)jarg2;
16056   arg3 = (Dali::Property::Value *)jarg3;
16057   if (!arg3) {
16058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16059     return 0;
16060   }
16061   {
16062     try {
16063       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16064     } catch (std::out_of_range& e) {
16065       {
16066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16067       };
16068     } catch (std::exception& e) {
16069       {
16070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16071       };
16072     } catch (Dali::DaliException e) {
16073       {
16074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16075       };
16076     } catch (...) {
16077       {
16078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16079       };
16080     }
16081   }
16082
16083   jresult = (void *)result;
16084   return jresult;
16085 }
16086
16087
16088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16089   void * jresult ;
16090   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16091   Dali::Property::Index arg2 ;
16092   Dali::Property::Value *arg3 = 0 ;
16093   Dali::Property::Map *result = 0 ;
16094
16095   arg1 = (Dali::Property::Map *)jarg1;
16096   arg2 = (Dali::Property::Index)jarg2;
16097   arg3 = (Dali::Property::Value *)jarg3;
16098   if (!arg3) {
16099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16100     return 0;
16101   }
16102   {
16103     try {
16104       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16105     } catch (std::out_of_range& e) {
16106       {
16107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16108       };
16109     } catch (std::exception& e) {
16110       {
16111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16112       };
16113     } catch (Dali::DaliException e) {
16114       {
16115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16116       };
16117     } catch (...) {
16118       {
16119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16120       };
16121     }
16122   }
16123
16124   jresult = (void *)result;
16125   return jresult;
16126 }
16127
16128
16129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16130   void * jresult ;
16131   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16132   Dali::Property::Map::SizeType arg2 ;
16133   Dali::Property::Value *result = 0 ;
16134
16135   arg1 = (Dali::Property::Map *)jarg1;
16136   arg2 = (Dali::Property::Map::SizeType)jarg2;
16137   {
16138     try {
16139       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16140     } catch (std::out_of_range& e) {
16141       {
16142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16143       };
16144     } catch (std::exception& e) {
16145       {
16146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16147       };
16148     } catch (Dali::DaliException e) {
16149       {
16150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16151       };
16152     } catch (...) {
16153       {
16154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16155       };
16156     }
16157   }
16158
16159   jresult = (void *)result;
16160   return jresult;
16161 }
16162
16163
16164 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16165   char * jresult ;
16166   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16167   Dali::Property::Map::SizeType arg2 ;
16168   std::string *result = 0 ;
16169
16170   arg1 = (Dali::Property::Map *)jarg1;
16171   arg2 = (Dali::Property::Map::SizeType)jarg2;
16172   {
16173     try {
16174       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16175     } catch (std::out_of_range& e) {
16176       {
16177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16178       };
16179     } catch (std::exception& e) {
16180       {
16181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16182       };
16183     } catch (Dali::DaliException e) {
16184       {
16185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16186       };
16187     } catch (...) {
16188       {
16189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16190       };
16191     }
16192   }
16193
16194   jresult = SWIG_csharp_string_callback(result->c_str());
16195   return jresult;
16196 }
16197
16198
16199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16200   void * jresult ;
16201   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16202   Dali::Property::Map::SizeType arg2 ;
16203   SwigValueWrapper< Dali::Property::Key > result;
16204
16205   arg1 = (Dali::Property::Map *)jarg1;
16206   arg2 = (Dali::Property::Map::SizeType)jarg2;
16207   {
16208     try {
16209       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16210     } catch (std::out_of_range& e) {
16211       {
16212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16213       };
16214     } catch (std::exception& e) {
16215       {
16216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16217       };
16218     } catch (Dali::DaliException e) {
16219       {
16220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16221       };
16222     } catch (...) {
16223       {
16224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16225       };
16226     }
16227   }
16228
16229   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16230   return jresult;
16231 }
16232
16233
16234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16235   void * jresult ;
16236   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16237   Dali::Property::Map::SizeType arg2 ;
16238   StringValuePair *result = 0 ;
16239
16240   arg1 = (Dali::Property::Map *)jarg1;
16241   arg2 = (Dali::Property::Map::SizeType)jarg2;
16242   {
16243     try {
16244       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16245     } catch (std::out_of_range& e) {
16246       {
16247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16248       };
16249     } catch (std::exception& e) {
16250       {
16251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16252       };
16253     } catch (Dali::DaliException e) {
16254       {
16255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16256       };
16257     } catch (...) {
16258       {
16259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16260       };
16261     }
16262   }
16263
16264   jresult = (void *)result;
16265   return jresult;
16266 }
16267
16268
16269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16270   void * jresult ;
16271   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16272   char *arg2 = (char *) 0 ;
16273   Dali::Property::Value *result = 0 ;
16274
16275   arg1 = (Dali::Property::Map *)jarg1;
16276   arg2 = (char *)jarg2;
16277   {
16278     try {
16279       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16280     } catch (std::out_of_range& e) {
16281       {
16282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16283       };
16284     } catch (std::exception& e) {
16285       {
16286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16287       };
16288     } catch (Dali::DaliException e) {
16289       {
16290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16291       };
16292     } catch (...) {
16293       {
16294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16295       };
16296     }
16297   }
16298
16299   jresult = (void *)result;
16300   return jresult;
16301 }
16302
16303
16304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16305   void * jresult ;
16306   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16307   Dali::Property::Index arg2 ;
16308   Dali::Property::Value *result = 0 ;
16309
16310   arg1 = (Dali::Property::Map *)jarg1;
16311   arg2 = (Dali::Property::Index)jarg2;
16312   {
16313     try {
16314       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16315     } catch (std::out_of_range& e) {
16316       {
16317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16318       };
16319     } catch (std::exception& e) {
16320       {
16321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16322       };
16323     } catch (Dali::DaliException e) {
16324       {
16325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16326       };
16327     } catch (...) {
16328       {
16329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16330       };
16331     }
16332   }
16333
16334   jresult = (void *)result;
16335   return jresult;
16336 }
16337
16338
16339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16340   void * jresult ;
16341   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16342   Dali::Property::Index arg2 ;
16343   std::string *arg3 = 0 ;
16344   Dali::Property::Value *result = 0 ;
16345
16346   arg1 = (Dali::Property::Map *)jarg1;
16347   arg2 = (Dali::Property::Index)jarg2;
16348   if (!jarg3) {
16349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16350     return 0;
16351   }
16352   std::string arg3_str(jarg3);
16353   arg3 = &arg3_str;
16354   {
16355     try {
16356       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16357     } catch (std::out_of_range& e) {
16358       {
16359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16360       };
16361     } catch (std::exception& e) {
16362       {
16363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16364       };
16365     } catch (Dali::DaliException e) {
16366       {
16367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16368       };
16369     } catch (...) {
16370       {
16371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16372       };
16373     }
16374   }
16375
16376   jresult = (void *)result;
16377
16378   //argout typemap for const std::string&
16379
16380   return jresult;
16381 }
16382
16383
16384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16385   void * jresult ;
16386   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16387   std::string *arg2 = 0 ;
16388   Dali::Property::Type arg3 ;
16389   Dali::Property::Value *result = 0 ;
16390
16391   arg1 = (Dali::Property::Map *)jarg1;
16392   if (!jarg2) {
16393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16394     return 0;
16395   }
16396   std::string arg2_str(jarg2);
16397   arg2 = &arg2_str;
16398   arg3 = (Dali::Property::Type)jarg3;
16399   {
16400     try {
16401       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16402     } catch (std::out_of_range& e) {
16403       {
16404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16405       };
16406     } catch (std::exception& e) {
16407       {
16408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16409       };
16410     } catch (Dali::DaliException e) {
16411       {
16412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16413       };
16414     } catch (...) {
16415       {
16416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16417       };
16418     }
16419   }
16420
16421   jresult = (void *)result;
16422
16423   //argout typemap for const std::string&
16424
16425   return jresult;
16426 }
16427
16428
16429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16430   void * jresult ;
16431   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16432   Dali::Property::Index arg2 ;
16433   Dali::Property::Type arg3 ;
16434   Dali::Property::Value *result = 0 ;
16435
16436   arg1 = (Dali::Property::Map *)jarg1;
16437   arg2 = (Dali::Property::Index)jarg2;
16438   arg3 = (Dali::Property::Type)jarg3;
16439   {
16440     try {
16441       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16442     } catch (std::out_of_range& e) {
16443       {
16444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16445       };
16446     } catch (std::exception& e) {
16447       {
16448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16449       };
16450     } catch (Dali::DaliException e) {
16451       {
16452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16453       };
16454     } catch (...) {
16455       {
16456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16457       };
16458     }
16459   }
16460
16461   jresult = (void *)result;
16462   return jresult;
16463 }
16464
16465
16466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16467   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16468
16469   arg1 = (Dali::Property::Map *)jarg1;
16470   {
16471     try {
16472       (arg1)->Clear();
16473     } catch (std::out_of_range& e) {
16474       {
16475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16476       };
16477     } catch (std::exception& e) {
16478       {
16479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16480       };
16481     } catch (Dali::DaliException e) {
16482       {
16483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16484       };
16485     } catch (...) {
16486       {
16487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16488       };
16489     }
16490   }
16491
16492 }
16493
16494
16495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16496   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16497   Dali::Property::Map *arg2 = 0 ;
16498
16499   arg1 = (Dali::Property::Map *)jarg1;
16500   arg2 = (Dali::Property::Map *)jarg2;
16501   if (!arg2) {
16502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16503     return ;
16504   }
16505   {
16506     try {
16507       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16508     } catch (std::out_of_range& e) {
16509       {
16510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16511       };
16512     } catch (std::exception& e) {
16513       {
16514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16515       };
16516     } catch (Dali::DaliException e) {
16517       {
16518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16519       };
16520     } catch (...) {
16521       {
16522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16523       };
16524     }
16525   }
16526
16527 }
16528
16529
16530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16531   void * jresult ;
16532   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16533   std::string *arg2 = 0 ;
16534   Dali::Property::Value *result = 0 ;
16535
16536   arg1 = (Dali::Property::Map *)jarg1;
16537   if (!jarg2) {
16538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16539     return 0;
16540   }
16541   std::string arg2_str(jarg2);
16542   arg2 = &arg2_str;
16543   {
16544     try {
16545       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16546     } catch (std::out_of_range& e) {
16547       {
16548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16549       };
16550     } catch (std::exception& e) {
16551       {
16552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16553       };
16554     } catch (Dali::DaliException e) {
16555       {
16556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16557       };
16558     } catch (...) {
16559       {
16560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16561       };
16562     }
16563   }
16564
16565   jresult = (void *)result;
16566
16567   //argout typemap for const std::string&
16568
16569   return jresult;
16570 }
16571
16572
16573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16574   void * jresult ;
16575   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16576   Dali::Property::Index arg2 ;
16577   Dali::Property::Value *result = 0 ;
16578
16579   arg1 = (Dali::Property::Map *)jarg1;
16580   arg2 = (Dali::Property::Index)jarg2;
16581   {
16582     try {
16583       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16584     } catch (std::out_of_range& e) {
16585       {
16586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16587       };
16588     } catch (std::exception& e) {
16589       {
16590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16591       };
16592     } catch (Dali::DaliException e) {
16593       {
16594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16595       };
16596     } catch (...) {
16597       {
16598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16599       };
16600     }
16601   }
16602
16603   jresult = (void *)result;
16604   return jresult;
16605 }
16606
16607
16608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16609   void * jresult ;
16610   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16611   Dali::Property::Map *arg2 = 0 ;
16612   Dali::Property::Map *result = 0 ;
16613
16614   arg1 = (Dali::Property::Map *)jarg1;
16615   arg2 = (Dali::Property::Map *)jarg2;
16616   if (!arg2) {
16617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16618     return 0;
16619   }
16620   {
16621     try {
16622       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16623     } catch (std::out_of_range& e) {
16624       {
16625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16626       };
16627     } catch (std::exception& e) {
16628       {
16629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16630       };
16631     } catch (Dali::DaliException e) {
16632       {
16633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16634       };
16635     } catch (...) {
16636       {
16637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16638       };
16639     }
16640   }
16641
16642   jresult = (void *)result;
16643   return jresult;
16644 }
16645
16646
16647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16648   void * jresult ;
16649   Dali::Property::Value *result = 0 ;
16650
16651   {
16652     try {
16653       result = (Dali::Property::Value *)new Dali::Property::Value();
16654     } catch (std::out_of_range& e) {
16655       {
16656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16657       };
16658     } catch (std::exception& e) {
16659       {
16660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16661       };
16662     } catch (Dali::DaliException e) {
16663       {
16664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16665       };
16666     } catch (...) {
16667       {
16668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16669       };
16670     }
16671   }
16672
16673   jresult = (void *)result;
16674   return jresult;
16675 }
16676
16677
16678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16679   void * jresult ;
16680   bool arg1 ;
16681   Dali::Property::Value *result = 0 ;
16682
16683   arg1 = jarg1 ? true : false;
16684   {
16685     try {
16686       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16687     } catch (std::out_of_range& e) {
16688       {
16689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16690       };
16691     } catch (std::exception& e) {
16692       {
16693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16694       };
16695     } catch (Dali::DaliException e) {
16696       {
16697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16698       };
16699     } catch (...) {
16700       {
16701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16702       };
16703     }
16704   }
16705
16706   jresult = (void *)result;
16707   return jresult;
16708 }
16709
16710
16711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16712   void * jresult ;
16713   int arg1 ;
16714   Dali::Property::Value *result = 0 ;
16715
16716   arg1 = (int)jarg1;
16717   {
16718     try {
16719       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16720     } catch (std::out_of_range& e) {
16721       {
16722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16723       };
16724     } catch (std::exception& e) {
16725       {
16726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16727       };
16728     } catch (Dali::DaliException e) {
16729       {
16730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16731       };
16732     } catch (...) {
16733       {
16734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16735       };
16736     }
16737   }
16738
16739   jresult = (void *)result;
16740   return jresult;
16741 }
16742
16743
16744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16745   void * jresult ;
16746   float arg1 ;
16747   Dali::Property::Value *result = 0 ;
16748
16749   arg1 = (float)jarg1;
16750   {
16751     try {
16752       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16753     } catch (std::out_of_range& e) {
16754       {
16755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16756       };
16757     } catch (std::exception& e) {
16758       {
16759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16760       };
16761     } catch (Dali::DaliException e) {
16762       {
16763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16764       };
16765     } catch (...) {
16766       {
16767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16768       };
16769     }
16770   }
16771
16772   jresult = (void *)result;
16773   return jresult;
16774 }
16775
16776
16777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16778   void * jresult ;
16779   Dali::Vector2 *arg1 = 0 ;
16780   Dali::Property::Value *result = 0 ;
16781
16782   arg1 = (Dali::Vector2 *)jarg1;
16783   if (!arg1) {
16784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16785     return 0;
16786   }
16787   {
16788     try {
16789       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16790     } catch (std::out_of_range& e) {
16791       {
16792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16793       };
16794     } catch (std::exception& e) {
16795       {
16796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16797       };
16798     } catch (Dali::DaliException e) {
16799       {
16800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16801       };
16802     } catch (...) {
16803       {
16804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16805       };
16806     }
16807   }
16808
16809   jresult = (void *)result;
16810   return jresult;
16811 }
16812
16813
16814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16815   void * jresult ;
16816   Dali::Vector3 *arg1 = 0 ;
16817   Dali::Property::Value *result = 0 ;
16818
16819   arg1 = (Dali::Vector3 *)jarg1;
16820   if (!arg1) {
16821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16822     return 0;
16823   }
16824   {
16825     try {
16826       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16827     } catch (std::out_of_range& e) {
16828       {
16829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16830       };
16831     } catch (std::exception& e) {
16832       {
16833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16834       };
16835     } catch (Dali::DaliException e) {
16836       {
16837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16838       };
16839     } catch (...) {
16840       {
16841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16842       };
16843     }
16844   }
16845
16846   jresult = (void *)result;
16847   return jresult;
16848 }
16849
16850
16851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16852   void * jresult ;
16853   Dali::Vector4 *arg1 = 0 ;
16854   Dali::Property::Value *result = 0 ;
16855
16856   arg1 = (Dali::Vector4 *)jarg1;
16857   if (!arg1) {
16858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16859     return 0;
16860   }
16861   {
16862     try {
16863       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16864     } catch (std::out_of_range& e) {
16865       {
16866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16867       };
16868     } catch (std::exception& e) {
16869       {
16870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16871       };
16872     } catch (Dali::DaliException e) {
16873       {
16874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16875       };
16876     } catch (...) {
16877       {
16878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16879       };
16880     }
16881   }
16882
16883   jresult = (void *)result;
16884   return jresult;
16885 }
16886
16887
16888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16889   void * jresult ;
16890   Dali::Matrix3 *arg1 = 0 ;
16891   Dali::Property::Value *result = 0 ;
16892
16893   arg1 = (Dali::Matrix3 *)jarg1;
16894   if (!arg1) {
16895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16896     return 0;
16897   }
16898   {
16899     try {
16900       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16901     } catch (std::out_of_range& e) {
16902       {
16903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16904       };
16905     } catch (std::exception& e) {
16906       {
16907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16908       };
16909     } catch (Dali::DaliException e) {
16910       {
16911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16912       };
16913     } catch (...) {
16914       {
16915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16916       };
16917     }
16918   }
16919
16920   jresult = (void *)result;
16921   return jresult;
16922 }
16923
16924
16925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16926   void * jresult ;
16927   Dali::Matrix *arg1 = 0 ;
16928   Dali::Property::Value *result = 0 ;
16929
16930   arg1 = (Dali::Matrix *)jarg1;
16931   if (!arg1) {
16932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16933     return 0;
16934   }
16935   {
16936     try {
16937       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16938     } catch (std::out_of_range& e) {
16939       {
16940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16941       };
16942     } catch (std::exception& e) {
16943       {
16944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16945       };
16946     } catch (Dali::DaliException e) {
16947       {
16948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16949       };
16950     } catch (...) {
16951       {
16952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16953       };
16954     }
16955   }
16956
16957   jresult = (void *)result;
16958   return jresult;
16959 }
16960
16961
16962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16963   void * jresult ;
16964   Dali::Rect< int > *arg1 = 0 ;
16965   Dali::Property::Value *result = 0 ;
16966
16967   arg1 = (Dali::Rect< int > *)jarg1;
16968   if (!arg1) {
16969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16970     return 0;
16971   }
16972   {
16973     try {
16974       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16975     } catch (std::out_of_range& e) {
16976       {
16977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16978       };
16979     } catch (std::exception& e) {
16980       {
16981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16982       };
16983     } catch (Dali::DaliException e) {
16984       {
16985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16986       };
16987     } catch (...) {
16988       {
16989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16990       };
16991     }
16992   }
16993
16994   jresult = (void *)result;
16995   return jresult;
16996 }
16997
16998
16999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17000   void * jresult ;
17001   Dali::AngleAxis *arg1 = 0 ;
17002   Dali::Property::Value *result = 0 ;
17003
17004   arg1 = (Dali::AngleAxis *)jarg1;
17005   if (!arg1) {
17006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17007     return 0;
17008   }
17009   {
17010     try {
17011       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17012     } catch (std::out_of_range& e) {
17013       {
17014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17015       };
17016     } catch (std::exception& e) {
17017       {
17018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17019       };
17020     } catch (Dali::DaliException e) {
17021       {
17022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17023       };
17024     } catch (...) {
17025       {
17026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17027       };
17028     }
17029   }
17030
17031   jresult = (void *)result;
17032   return jresult;
17033 }
17034
17035
17036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17037   void * jresult ;
17038   Dali::Quaternion *arg1 = 0 ;
17039   Dali::Property::Value *result = 0 ;
17040
17041   arg1 = (Dali::Quaternion *)jarg1;
17042   if (!arg1) {
17043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17044     return 0;
17045   }
17046   {
17047     try {
17048       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17049     } catch (std::out_of_range& e) {
17050       {
17051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17052       };
17053     } catch (std::exception& e) {
17054       {
17055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17056       };
17057     } catch (Dali::DaliException e) {
17058       {
17059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17060       };
17061     } catch (...) {
17062       {
17063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17064       };
17065     }
17066   }
17067
17068   jresult = (void *)result;
17069   return jresult;
17070 }
17071
17072
17073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17074   void * jresult ;
17075   std::string *arg1 = 0 ;
17076   Dali::Property::Value *result = 0 ;
17077
17078   if (!jarg1) {
17079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17080     return 0;
17081   }
17082   std::string arg1_str(jarg1);
17083   arg1 = &arg1_str;
17084   {
17085     try {
17086       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17087     } catch (std::out_of_range& e) {
17088       {
17089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17090       };
17091     } catch (std::exception& e) {
17092       {
17093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17094       };
17095     } catch (Dali::DaliException e) {
17096       {
17097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17098       };
17099     } catch (...) {
17100       {
17101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17102       };
17103     }
17104   }
17105
17106   jresult = (void *)result;
17107
17108   //argout typemap for const std::string&
17109
17110   return jresult;
17111 }
17112
17113
17114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17115   void * jresult ;
17116   Dali::Property::Array *arg1 = 0 ;
17117   Dali::Property::Value *result = 0 ;
17118
17119   arg1 = (Dali::Property::Array *)jarg1;
17120   if (!arg1) {
17121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17122     return 0;
17123   }
17124   {
17125     try {
17126       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17127     } catch (std::out_of_range& e) {
17128       {
17129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17130       };
17131     } catch (std::exception& e) {
17132       {
17133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17134       };
17135     } catch (Dali::DaliException e) {
17136       {
17137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17138       };
17139     } catch (...) {
17140       {
17141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17142       };
17143     }
17144   }
17145
17146   jresult = (void *)result;
17147   return jresult;
17148 }
17149
17150
17151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17152   void * jresult ;
17153   Dali::Property::Map *arg1 = 0 ;
17154   Dali::Property::Value *result = 0 ;
17155
17156   arg1 = (Dali::Property::Map *)jarg1;
17157   if (!arg1) {
17158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17159     return 0;
17160   }
17161   {
17162     try {
17163       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17164     } catch (std::out_of_range& e) {
17165       {
17166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17167       };
17168     } catch (std::exception& e) {
17169       {
17170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17171       };
17172     } catch (Dali::DaliException e) {
17173       {
17174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17175       };
17176     } catch (...) {
17177       {
17178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17179       };
17180     }
17181   }
17182
17183   jresult = (void *)result;
17184   return jresult;
17185 }
17186
17187
17188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17189   void * jresult ;
17190   Extents *arg1 = 0 ;
17191   Dali::Property::Value *result = 0 ;
17192
17193   arg1 = (Extents *)jarg1;
17194   if (!arg1) {
17195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17196     return 0;
17197   }
17198   {
17199     try {
17200       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17201     } catch (std::out_of_range& e) {
17202       {
17203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17204       };
17205     } catch (std::exception& e) {
17206       {
17207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17208       };
17209     } catch (...) {
17210       {
17211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17212       };
17213     }
17214   }
17215   jresult = (void *)result;
17216   return jresult;
17217 }
17218
17219
17220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17221   void * jresult ;
17222   Dali::Property::Type arg1 ;
17223   Dali::Property::Value *result = 0 ;
17224
17225   arg1 = (Dali::Property::Type)jarg1;
17226   {
17227     try {
17228       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17229     } catch (std::out_of_range& e) {
17230       {
17231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17232       };
17233     } catch (std::exception& e) {
17234       {
17235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17236       };
17237     } catch (Dali::DaliException e) {
17238       {
17239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17240       };
17241     } catch (...) {
17242       {
17243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17244       };
17245     }
17246   }
17247
17248   jresult = (void *)result;
17249   return jresult;
17250 }
17251
17252
17253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17254   void * jresult ;
17255   Dali::Property::Value *arg1 = 0 ;
17256   Dali::Property::Value *result = 0 ;
17257
17258   arg1 = (Dali::Property::Value *)jarg1;
17259   if (!arg1) {
17260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17261     return 0;
17262   }
17263   {
17264     try {
17265       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17266     } catch (std::out_of_range& e) {
17267       {
17268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17269       };
17270     } catch (std::exception& e) {
17271       {
17272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17273       };
17274     } catch (Dali::DaliException e) {
17275       {
17276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17277       };
17278     } catch (...) {
17279       {
17280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17281       };
17282     }
17283   }
17284
17285   jresult = (void *)result;
17286   return jresult;
17287 }
17288
17289
17290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17291   void * jresult ;
17292   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17293   Dali::Property::Value *arg2 = 0 ;
17294   Dali::Property::Value *result = 0 ;
17295
17296   arg1 = (Dali::Property::Value *)jarg1;
17297   arg2 = (Dali::Property::Value *)jarg2;
17298   if (!arg2) {
17299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17300     return 0;
17301   }
17302   {
17303     try {
17304       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17305     } catch (std::out_of_range& e) {
17306       {
17307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17308       };
17309     } catch (std::exception& e) {
17310       {
17311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17312       };
17313     } catch (Dali::DaliException e) {
17314       {
17315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17316       };
17317     } catch (...) {
17318       {
17319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17320       };
17321     }
17322   }
17323
17324   jresult = (void *)result;
17325   return jresult;
17326 }
17327
17328
17329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17330   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17331
17332   arg1 = (Dali::Property::Value *)jarg1;
17333   {
17334     try {
17335       delete arg1;
17336     } catch (std::out_of_range& e) {
17337       {
17338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17339       };
17340     } catch (std::exception& e) {
17341       {
17342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17343       };
17344     } catch (Dali::DaliException e) {
17345       {
17346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17347       };
17348     } catch (...) {
17349       {
17350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17351       };
17352     }
17353   }
17354
17355 }
17356
17357
17358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17359   int jresult ;
17360   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17361   Dali::Property::Type result;
17362
17363   arg1 = (Dali::Property::Value *)jarg1;
17364   {
17365     try {
17366       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17367     } catch (std::out_of_range& e) {
17368       {
17369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17370       };
17371     } catch (std::exception& e) {
17372       {
17373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17374       };
17375     } catch (Dali::DaliException e) {
17376       {
17377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17378       };
17379     } catch (...) {
17380       {
17381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17382       };
17383     }
17384   }
17385
17386   jresult = (int)result;
17387   return jresult;
17388 }
17389
17390
17391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17392   unsigned int jresult ;
17393   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17394   bool *arg2 = 0 ;
17395   bool result;
17396
17397   arg1 = (Dali::Property::Value *)jarg1;
17398   arg2 = (bool *)jarg2;
17399   {
17400     try {
17401       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17402     } catch (std::out_of_range& e) {
17403       {
17404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17405       };
17406     } catch (std::exception& e) {
17407       {
17408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17409       };
17410     } catch (Dali::DaliException e) {
17411       {
17412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17413       };
17414     } catch (...) {
17415       {
17416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17417       };
17418     }
17419   }
17420
17421   jresult = result;
17422   return jresult;
17423 }
17424
17425
17426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17427   unsigned int jresult ;
17428   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17429   float *arg2 = 0 ;
17430   bool result;
17431
17432   arg1 = (Dali::Property::Value *)jarg1;
17433   arg2 = (float *)jarg2;
17434   {
17435     try {
17436       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17437     } catch (std::out_of_range& e) {
17438       {
17439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17440       };
17441     } catch (std::exception& e) {
17442       {
17443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17444       };
17445     } catch (Dali::DaliException e) {
17446       {
17447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17448       };
17449     } catch (...) {
17450       {
17451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17452       };
17453     }
17454   }
17455
17456   jresult = result;
17457   return jresult;
17458 }
17459
17460
17461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17462   unsigned int jresult ;
17463   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17464   int *arg2 = 0 ;
17465   bool result;
17466
17467   arg1 = (Dali::Property::Value *)jarg1;
17468   arg2 = (int *)jarg2;
17469   {
17470     try {
17471       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17472     } catch (std::out_of_range& e) {
17473       {
17474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17475       };
17476     } catch (std::exception& e) {
17477       {
17478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17479       };
17480     } catch (Dali::DaliException e) {
17481       {
17482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17483       };
17484     } catch (...) {
17485       {
17486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17487       };
17488     }
17489   }
17490
17491   jresult = result;
17492   return jresult;
17493 }
17494
17495
17496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17497   unsigned int jresult ;
17498   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17499   Dali::Rect< int > *arg2 = 0 ;
17500   bool result;
17501
17502   arg1 = (Dali::Property::Value *)jarg1;
17503   arg2 = (Dali::Rect< int > *)jarg2;
17504   if (!arg2) {
17505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17506     return 0;
17507   }
17508   {
17509     try {
17510       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17511     } catch (std::out_of_range& e) {
17512       {
17513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17514       };
17515     } catch (std::exception& e) {
17516       {
17517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17518       };
17519     } catch (Dali::DaliException e) {
17520       {
17521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17522       };
17523     } catch (...) {
17524       {
17525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17526       };
17527     }
17528   }
17529
17530   jresult = result;
17531   return jresult;
17532 }
17533
17534
17535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17536   unsigned int jresult ;
17537   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17538   Dali::Vector2 *arg2 = 0 ;
17539   bool result;
17540
17541   arg1 = (Dali::Property::Value *)jarg1;
17542   arg2 = (Dali::Vector2 *)jarg2;
17543   if (!arg2) {
17544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17545     return 0;
17546   }
17547   {
17548     try {
17549       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17550     } catch (std::out_of_range& e) {
17551       {
17552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17553       };
17554     } catch (std::exception& e) {
17555       {
17556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17557       };
17558     } catch (Dali::DaliException e) {
17559       {
17560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17561       };
17562     } catch (...) {
17563       {
17564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17565       };
17566     }
17567   }
17568
17569   jresult = result;
17570   return jresult;
17571 }
17572
17573
17574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17575   unsigned int jresult ;
17576   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17577   Dali::Vector3 *arg2 = 0 ;
17578   bool result;
17579
17580   arg1 = (Dali::Property::Value *)jarg1;
17581   arg2 = (Dali::Vector3 *)jarg2;
17582   if (!arg2) {
17583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17584     return 0;
17585   }
17586   {
17587     try {
17588       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17589     } catch (std::out_of_range& e) {
17590       {
17591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17592       };
17593     } catch (std::exception& e) {
17594       {
17595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17596       };
17597     } catch (Dali::DaliException e) {
17598       {
17599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17600       };
17601     } catch (...) {
17602       {
17603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17604       };
17605     }
17606   }
17607
17608   jresult = result;
17609   return jresult;
17610 }
17611
17612
17613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17614   unsigned int jresult ;
17615   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17616   Dali::Vector4 *arg2 = 0 ;
17617   bool result;
17618
17619   arg1 = (Dali::Property::Value *)jarg1;
17620   arg2 = (Dali::Vector4 *)jarg2;
17621   if (!arg2) {
17622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17623     return 0;
17624   }
17625   {
17626     try {
17627       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17628     } catch (std::out_of_range& e) {
17629       {
17630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17631       };
17632     } catch (std::exception& e) {
17633       {
17634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17635       };
17636     } catch (Dali::DaliException e) {
17637       {
17638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17639       };
17640     } catch (...) {
17641       {
17642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17643       };
17644     }
17645   }
17646
17647   jresult = result;
17648   return jresult;
17649 }
17650
17651
17652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17653   unsigned int jresult ;
17654   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17655   Dali::Matrix3 *arg2 = 0 ;
17656   bool result;
17657
17658   arg1 = (Dali::Property::Value *)jarg1;
17659   arg2 = (Dali::Matrix3 *)jarg2;
17660   if (!arg2) {
17661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17662     return 0;
17663   }
17664   {
17665     try {
17666       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17667     } catch (std::out_of_range& e) {
17668       {
17669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17670       };
17671     } catch (std::exception& e) {
17672       {
17673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17674       };
17675     } catch (Dali::DaliException e) {
17676       {
17677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17678       };
17679     } catch (...) {
17680       {
17681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17682       };
17683     }
17684   }
17685
17686   jresult = result;
17687   return jresult;
17688 }
17689
17690
17691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17692   unsigned int jresult ;
17693   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17694   Dali::Matrix *arg2 = 0 ;
17695   bool result;
17696
17697   arg1 = (Dali::Property::Value *)jarg1;
17698   arg2 = (Dali::Matrix *)jarg2;
17699   if (!arg2) {
17700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17701     return 0;
17702   }
17703   {
17704     try {
17705       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17706     } catch (std::out_of_range& e) {
17707       {
17708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17709       };
17710     } catch (std::exception& e) {
17711       {
17712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17713       };
17714     } catch (Dali::DaliException e) {
17715       {
17716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17717       };
17718     } catch (...) {
17719       {
17720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17721       };
17722     }
17723   }
17724
17725   jresult = result;
17726   return jresult;
17727 }
17728
17729
17730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17731   unsigned int jresult ;
17732   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17733   Dali::AngleAxis *arg2 = 0 ;
17734   bool result;
17735
17736   arg1 = (Dali::Property::Value *)jarg1;
17737   arg2 = (Dali::AngleAxis *)jarg2;
17738   if (!arg2) {
17739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17740     return 0;
17741   }
17742   {
17743     try {
17744       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17745     } catch (std::out_of_range& e) {
17746       {
17747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17748       };
17749     } catch (std::exception& e) {
17750       {
17751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17752       };
17753     } catch (Dali::DaliException e) {
17754       {
17755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17756       };
17757     } catch (...) {
17758       {
17759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17760       };
17761     }
17762   }
17763
17764   jresult = result;
17765   return jresult;
17766 }
17767
17768
17769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17770   unsigned int jresult ;
17771   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17772   Dali::Quaternion *arg2 = 0 ;
17773   bool result;
17774
17775   arg1 = (Dali::Property::Value *)jarg1;
17776   arg2 = (Dali::Quaternion *)jarg2;
17777   if (!arg2) {
17778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17779     return 0;
17780   }
17781   {
17782     try {
17783       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17784     } catch (std::out_of_range& e) {
17785       {
17786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17787       };
17788     } catch (std::exception& e) {
17789       {
17790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17791       };
17792     } catch (Dali::DaliException e) {
17793       {
17794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17795       };
17796     } catch (...) {
17797       {
17798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17799       };
17800     }
17801   }
17802
17803   jresult = result;
17804   return jresult;
17805 }
17806
17807
17808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17809   unsigned int jresult ;
17810   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17811   std::string *arg2 = 0 ;
17812   bool result;
17813
17814   arg1 = (Dali::Property::Value *)jarg1;
17815
17816   //typemap in
17817   std::string temp;
17818   arg2 = &temp;
17819
17820   {
17821     try {
17822       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17823     } catch (std::out_of_range& e) {
17824       {
17825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17826       };
17827     } catch (std::exception& e) {
17828       {
17829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17830       };
17831     } catch (Dali::DaliException e) {
17832       {
17833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17834       };
17835     } catch (...) {
17836       {
17837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17838       };
17839     }
17840   }
17841
17842   jresult = result;
17843
17844   //Typemap argout in c++ file.
17845   //This will convert c++ string to c# string
17846   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17847
17848   return jresult;
17849 }
17850
17851
17852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17853   unsigned int jresult ;
17854   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17855   Dali::Property::Array *arg2 = 0 ;
17856   bool result;
17857
17858   arg1 = (Dali::Property::Value *)jarg1;
17859   arg2 = (Dali::Property::Array *)jarg2;
17860   if (!arg2) {
17861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17862     return 0;
17863   }
17864   {
17865     try {
17866       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17867     } catch (std::out_of_range& e) {
17868       {
17869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17870       };
17871     } catch (std::exception& e) {
17872       {
17873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17874       };
17875     } catch (Dali::DaliException e) {
17876       {
17877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17878       };
17879     } catch (...) {
17880       {
17881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17882       };
17883     }
17884   }
17885
17886   jresult = result;
17887   return jresult;
17888 }
17889
17890
17891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17892   unsigned int jresult ;
17893   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17894   Dali::Property::Map *arg2 = 0 ;
17895   bool result;
17896
17897   arg1 = (Dali::Property::Value *)jarg1;
17898   arg2 = (Dali::Property::Map *)jarg2;
17899   if (!arg2) {
17900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17901     return 0;
17902   }
17903   {
17904     try {
17905       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17906     } catch (std::out_of_range& e) {
17907       {
17908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17909       };
17910     } catch (std::exception& e) {
17911       {
17912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17913       };
17914     } catch (Dali::DaliException e) {
17915       {
17916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17917       };
17918     } catch (...) {
17919       {
17920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17921       };
17922     }
17923   }
17924
17925   jresult = result;
17926   return jresult;
17927 }
17928
17929
17930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17931   unsigned int jresult ;
17932   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17933   Extents *arg2 = 0 ;
17934   bool result;
17935
17936   arg1 = (Dali::Property::Value *)jarg1;
17937   arg2 = (Extents *)jarg2;
17938   if (!arg2) {
17939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17940     return 0;
17941   }
17942   {
17943     try {
17944       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17945     } catch (std::out_of_range& e) {
17946       {
17947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17948       };
17949     } catch (std::exception& e) {
17950       {
17951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17952       };
17953     } catch (...) {
17954       {
17955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17956       };
17957     }
17958   }
17959   jresult = result;
17960   return jresult;
17961 }
17962
17963
17964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17965   void * jresult ;
17966   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17967   Dali::Property::Array *result = 0 ;
17968
17969   arg1 = (Dali::Property::Value *)jarg1;
17970   {
17971     try {
17972       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17973     } catch (std::out_of_range& e) {
17974       {
17975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17976       };
17977     } catch (std::exception& e) {
17978       {
17979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17980       };
17981     } catch (Dali::DaliException e) {
17982       {
17983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17984       };
17985     } catch (...) {
17986       {
17987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17988       };
17989     }
17990   }
17991
17992   jresult = (void *)result;
17993   return jresult;
17994 }
17995
17996
17997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17998   void * jresult ;
17999   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18000   Dali::Property::Map *result = 0 ;
18001
18002   arg1 = (Dali::Property::Value *)jarg1;
18003   {
18004     try {
18005       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18006     } catch (std::out_of_range& e) {
18007       {
18008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18009       };
18010     } catch (std::exception& e) {
18011       {
18012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18013       };
18014     } catch (Dali::DaliException e) {
18015       {
18016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18017       };
18018     } catch (...) {
18019       {
18020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18021       };
18022     }
18023   }
18024
18025   jresult = (void *)result;
18026   return jresult;
18027 }
18028
18029
18030 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18031   char * jresult ;
18032   Dali::Property::Type arg1 ;
18033   char *result = 0 ;
18034
18035   arg1 = (Dali::Property::Type)jarg1;
18036   {
18037     try {
18038       result = (char *)Dali::PropertyTypes::GetName(arg1);
18039     } catch (std::out_of_range& e) {
18040       {
18041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18042       };
18043     } catch (std::exception& e) {
18044       {
18045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18046       };
18047     } catch (Dali::DaliException e) {
18048       {
18049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18050       };
18051     } catch (...) {
18052       {
18053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18054       };
18055     }
18056   }
18057
18058   jresult = SWIG_csharp_string_callback((const char *)result);
18059   return jresult;
18060 }
18061
18062
18063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18064   unsigned int jresult ;
18065   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18066   std::string *arg2 = 0 ;
18067   Dali::Property::Map *arg3 = 0 ;
18068   bool result;
18069
18070   arg1 = (Dali::BaseObject *)jarg1;
18071   if (!jarg2) {
18072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18073     return 0;
18074   }
18075   std::string arg2_str(jarg2);
18076   arg2 = &arg2_str;
18077   arg3 = (Dali::Property::Map *)jarg3;
18078   if (!arg3) {
18079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18080     return 0;
18081   }
18082   {
18083     try {
18084       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18085     } catch (std::out_of_range& e) {
18086       {
18087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18088       };
18089     } catch (std::exception& e) {
18090       {
18091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18092       };
18093     } catch (Dali::DaliException e) {
18094       {
18095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18096       };
18097     } catch (...) {
18098       {
18099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18100       };
18101     }
18102   }
18103
18104   jresult = result;
18105
18106   //argout typemap for const std::string&
18107
18108   return jresult;
18109 }
18110
18111
18112 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18113   char * jresult ;
18114   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18115   std::string *result = 0 ;
18116
18117   arg1 = (Dali::BaseObject *)jarg1;
18118   {
18119     try {
18120       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18121     } catch (std::out_of_range& e) {
18122       {
18123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18124       };
18125     } catch (std::exception& e) {
18126       {
18127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18128       };
18129     } catch (Dali::DaliException e) {
18130       {
18131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18132       };
18133     } catch (...) {
18134       {
18135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18136       };
18137     }
18138   }
18139
18140   jresult = SWIG_csharp_string_callback(result->c_str());
18141   return jresult;
18142 }
18143
18144
18145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18146   unsigned int jresult ;
18147   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18148   Dali::TypeInfo *arg2 = 0 ;
18149   bool result;
18150
18151   arg1 = (Dali::BaseObject *)jarg1;
18152   arg2 = (Dali::TypeInfo *)jarg2;
18153   if (!arg2) {
18154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18155     return 0;
18156   }
18157   {
18158     try {
18159       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18160     } catch (std::out_of_range& e) {
18161       {
18162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18163       };
18164     } catch (std::exception& e) {
18165       {
18166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18167       };
18168     } catch (Dali::DaliException e) {
18169       {
18170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18171       };
18172     } catch (...) {
18173       {
18174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18175       };
18176     }
18177   }
18178
18179   jresult = result;
18180   return jresult;
18181 }
18182
18183
18184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18185   unsigned int jresult ;
18186   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18187   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18188   std::string *arg3 = 0 ;
18189   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18190   bool result;
18191
18192   arg1 = (Dali::BaseObject *)jarg1;
18193   arg2 = (ConnectionTrackerInterface *)jarg2;
18194   if (!jarg3) {
18195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18196     return 0;
18197   }
18198   std::string arg3_str(jarg3);
18199   arg3 = &arg3_str;
18200   arg4 = (FunctorDelegate *)jarg4;
18201   {
18202     try {
18203       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18204     } catch (std::out_of_range& e) {
18205       {
18206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18207       };
18208     } catch (std::exception& e) {
18209       {
18210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18211       };
18212     } catch (Dali::DaliException e) {
18213       {
18214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18215       };
18216     } catch (...) {
18217       {
18218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18219       };
18220     }
18221   }
18222
18223   jresult = result;
18224
18225   //argout typemap for const std::string&
18226
18227   return jresult;
18228 }
18229
18230
18231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18232   void * jresult ;
18233   Dali::BaseHandle *arg1 = 0 ;
18234   Dali::BaseObject *result = 0 ;
18235
18236   arg1 = (Dali::BaseHandle *)jarg1;
18237   if (!arg1) {
18238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18239     return 0;
18240   }
18241   {
18242     try {
18243       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18244     } catch (std::out_of_range& e) {
18245       {
18246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18247       };
18248     } catch (std::exception& e) {
18249       {
18250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18251       };
18252     } catch (Dali::DaliException e) {
18253       {
18254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18255       };
18256     } catch (...) {
18257       {
18258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18259       };
18260     }
18261   }
18262
18263   jresult = (void *)result;
18264   return jresult;
18265 }
18266
18267
18268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18269   void * jresult ;
18270   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18271   Dali::BaseHandle *result = 0 ;
18272
18273   arg1 = (Dali::BaseObject *)jarg1;
18274   {
18275     try {
18276       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18277     } catch (std::out_of_range& e) {
18278       {
18279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18280       };
18281     } catch (std::exception& e) {
18282       {
18283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18284       };
18285     } catch (Dali::DaliException e) {
18286       {
18287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18288       };
18289     } catch (...) {
18290       {
18291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18292       };
18293     }
18294   }
18295
18296   jresult = (void *)result;
18297   return jresult;
18298 }
18299
18300
18301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18302   void * jresult ;
18303   Dali::BaseHandle *result = 0 ;
18304
18305   {
18306     try {
18307       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18308     } catch (std::out_of_range& e) {
18309       {
18310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18311       };
18312     } catch (std::exception& e) {
18313       {
18314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18315       };
18316     } catch (Dali::DaliException e) {
18317       {
18318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18319       };
18320     } catch (...) {
18321       {
18322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18323       };
18324     }
18325   }
18326
18327   jresult = (void *)result;
18328   return jresult;
18329 }
18330
18331
18332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18333   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18334
18335   arg1 = (Dali::BaseHandle *)jarg1;
18336   {
18337     try {
18338       delete arg1;
18339     } catch (std::out_of_range& e) {
18340       {
18341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18342       };
18343     } catch (std::exception& e) {
18344       {
18345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18346       };
18347     } catch (Dali::DaliException e) {
18348       {
18349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18350       };
18351     } catch (...) {
18352       {
18353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18354       };
18355     }
18356   }
18357
18358 }
18359
18360
18361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18362   void * jresult ;
18363   Dali::BaseHandle *arg1 = 0 ;
18364   Dali::BaseHandle *result = 0 ;
18365
18366   arg1 = (Dali::BaseHandle *)jarg1;
18367   if (!arg1) {
18368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18369     return 0;
18370   }
18371   {
18372     try {
18373       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18374     } catch (std::out_of_range& e) {
18375       {
18376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18377       };
18378     } catch (std::exception& e) {
18379       {
18380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18381       };
18382     } catch (Dali::DaliException e) {
18383       {
18384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18385       };
18386     } catch (...) {
18387       {
18388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18389       };
18390     }
18391   }
18392
18393   jresult = (void *)result;
18394   return jresult;
18395 }
18396
18397
18398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18399   void * jresult ;
18400   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18401   Dali::BaseHandle *arg2 = 0 ;
18402   Dali::BaseHandle *result = 0 ;
18403
18404   arg1 = (Dali::BaseHandle *)jarg1;
18405   arg2 = (Dali::BaseHandle *)jarg2;
18406   if (!arg2) {
18407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18408     return 0;
18409   }
18410   {
18411     try {
18412       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18413     } catch (std::out_of_range& e) {
18414       {
18415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18416       };
18417     } catch (std::exception& e) {
18418       {
18419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18420       };
18421     } catch (Dali::DaliException e) {
18422       {
18423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18424       };
18425     } catch (...) {
18426       {
18427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18428       };
18429     }
18430   }
18431
18432   jresult = (void *)result;
18433   return jresult;
18434 }
18435
18436
18437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18438   unsigned int jresult ;
18439   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18440   std::string *arg2 = 0 ;
18441   Dali::Property::Map *arg3 = 0 ;
18442   bool result;
18443
18444   arg1 = (Dali::BaseHandle *)jarg1;
18445   if (!jarg2) {
18446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18447     return 0;
18448   }
18449   std::string arg2_str(jarg2);
18450   arg2 = &arg2_str;
18451   arg3 = (Dali::Property::Map *)jarg3;
18452   if (!arg3) {
18453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18454     return 0;
18455   }
18456   {
18457     try {
18458       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18459     } catch (std::out_of_range& e) {
18460       {
18461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18462       };
18463     } catch (std::exception& e) {
18464       {
18465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18466       };
18467     } catch (Dali::DaliException e) {
18468       {
18469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18470       };
18471     } catch (...) {
18472       {
18473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18474       };
18475     }
18476   }
18477
18478   jresult = result;
18479
18480   //argout typemap for const std::string&
18481
18482   return jresult;
18483 }
18484
18485
18486 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18487   char * jresult ;
18488   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18489   std::string *result = 0 ;
18490
18491   arg1 = (Dali::BaseHandle *)jarg1;
18492   {
18493     try {
18494       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18495     } catch (std::out_of_range& e) {
18496       {
18497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18498       };
18499     } catch (std::exception& e) {
18500       {
18501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18502       };
18503     } catch (Dali::DaliException e) {
18504       {
18505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18506       };
18507     } catch (...) {
18508       {
18509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18510       };
18511     }
18512   }
18513
18514   jresult = SWIG_csharp_string_callback(result->c_str());
18515   return jresult;
18516 }
18517
18518
18519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18520   unsigned int jresult ;
18521   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18522   Dali::TypeInfo *arg2 = 0 ;
18523   bool result;
18524
18525   arg1 = (Dali::BaseHandle *)jarg1;
18526   arg2 = (Dali::TypeInfo *)jarg2;
18527   if (!arg2) {
18528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18529     return 0;
18530   }
18531   {
18532     try {
18533       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18534     } catch (std::out_of_range& e) {
18535       {
18536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18537       };
18538     } catch (std::exception& e) {
18539       {
18540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18541       };
18542     } catch (Dali::DaliException e) {
18543       {
18544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18545       };
18546     } catch (...) {
18547       {
18548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18549       };
18550     }
18551   }
18552
18553   jresult = result;
18554   return jresult;
18555 }
18556
18557
18558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18559   void * jresult ;
18560   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18561   Dali::BaseObject *result = 0 ;
18562
18563   arg1 = (Dali::BaseHandle *)jarg1;
18564   {
18565     try {
18566       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18567     } catch (std::out_of_range& e) {
18568       {
18569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18570       };
18571     } catch (std::exception& e) {
18572       {
18573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18574       };
18575     } catch (Dali::DaliException e) {
18576       {
18577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18578       };
18579     } catch (...) {
18580       {
18581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18582       };
18583     }
18584   }
18585
18586   jresult = (void *)result;
18587   return jresult;
18588 }
18589
18590
18591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18592   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18593
18594   arg1 = (Dali::BaseHandle *)jarg1;
18595   {
18596     try {
18597       (arg1)->Reset();
18598     } catch (std::out_of_range& e) {
18599       {
18600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18601       };
18602     } catch (std::exception& e) {
18603       {
18604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18605       };
18606     } catch (Dali::DaliException e) {
18607       {
18608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18609       };
18610     } catch (...) {
18611       {
18612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18613       };
18614     }
18615   }
18616
18617 }
18618
18619
18620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18621   unsigned int jresult ;
18622   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18623   Dali::BaseHandle *arg2 = 0 ;
18624   bool result;
18625
18626   arg1 = (Dali::BaseHandle *)jarg1;
18627   arg2 = (Dali::BaseHandle *)jarg2;
18628   if (!arg2) {
18629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18630     return 0;
18631   }
18632   {
18633     try {
18634       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18635     } catch (std::out_of_range& e) {
18636       {
18637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18638       };
18639     } catch (std::exception& e) {
18640       {
18641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18642       };
18643     } catch (Dali::DaliException e) {
18644       {
18645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18646       };
18647     } catch (...) {
18648       {
18649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18650       };
18651     }
18652   }
18653
18654   jresult = result;
18655   return jresult;
18656 }
18657
18658
18659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18660   unsigned int jresult ;
18661   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18662   Dali::BaseHandle *arg2 = 0 ;
18663   bool result;
18664
18665   arg1 = (Dali::BaseHandle *)jarg1;
18666   arg2 = (Dali::BaseHandle *)jarg2;
18667   if (!arg2) {
18668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18669     return 0;
18670   }
18671   {
18672     try {
18673       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18674     } catch (std::out_of_range& e) {
18675       {
18676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18677       };
18678     } catch (std::exception& e) {
18679       {
18680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18681       };
18682     } catch (Dali::DaliException e) {
18683       {
18684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18685       };
18686     } catch (...) {
18687       {
18688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18689       };
18690     }
18691   }
18692
18693   jresult = result;
18694   return jresult;
18695 }
18696
18697
18698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18699   void * jresult ;
18700   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18701   Dali::RefObject *result = 0 ;
18702
18703   arg1 = (Dali::BaseHandle *)jarg1;
18704   {
18705     try {
18706       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18707     } catch (std::out_of_range& e) {
18708       {
18709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18710       };
18711     } catch (std::exception& e) {
18712       {
18713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18714       };
18715     } catch (Dali::DaliException e) {
18716       {
18717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18718       };
18719     } catch (...) {
18720       {
18721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18722       };
18723     }
18724   }
18725
18726   jresult = (void *)result;
18727   return jresult;
18728 }
18729
18730
18731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18732   unsigned int jresult ;
18733   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18734   bool result;
18735
18736   arg1 = (Dali::BaseHandle *)jarg1;
18737   {
18738     try {
18739       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18740     } catch (std::out_of_range& e) {
18741       {
18742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18743       };
18744     } catch (std::exception& e) {
18745       {
18746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18747       };
18748     } catch (Dali::DaliException e) {
18749       {
18750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18751       };
18752     } catch (...) {
18753       {
18754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18755       };
18756     }
18757   }
18758
18759   jresult = result;
18760   return jresult;
18761 }
18762
18763
18764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18765   unsigned int jresult ;
18766   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18767   Dali::BaseHandle *arg2 = 0 ;
18768   bool result;
18769
18770   arg1 = (Dali::BaseHandle *)jarg1;
18771   arg2 = (Dali::BaseHandle *)jarg2;
18772   if (!arg2) {
18773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18774     return 0;
18775   }
18776   {
18777     try {
18778       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18779     } catch (std::out_of_range& e) {
18780       {
18781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18782       };
18783     } catch (std::exception& e) {
18784       {
18785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18786       };
18787     } catch (Dali::DaliException e) {
18788       {
18789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18790       };
18791     } catch (...) {
18792       {
18793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18794       };
18795     }
18796   }
18797
18798   jresult = result;
18799   return jresult;
18800 }
18801
18802
18803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18804   unsigned int jresult ;
18805   Dali::BaseHandle *arg1 = 0 ;
18806   Dali::BaseHandle *arg2 = 0 ;
18807   bool result;
18808
18809   arg1 = (Dali::BaseHandle *)jarg1;
18810   if (!arg1) {
18811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18812     return 0;
18813   }
18814   arg2 = (Dali::BaseHandle *)jarg2;
18815   if (!arg2) {
18816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18817     return 0;
18818   }
18819   {
18820     try {
18821       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18822     } catch (std::out_of_range& e) {
18823       {
18824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18825       };
18826     } catch (std::exception& e) {
18827       {
18828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18829       };
18830     } catch (Dali::DaliException e) {
18831       {
18832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18833       };
18834     } catch (...) {
18835       {
18836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18837       };
18838     }
18839   }
18840
18841   jresult = result;
18842   return jresult;
18843 }
18844
18845
18846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18847   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18848
18849   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18850   {
18851     try {
18852       delete arg1;
18853     } catch (std::out_of_range& e) {
18854       {
18855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18856       };
18857     } catch (std::exception& e) {
18858       {
18859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18860       };
18861     } catch (Dali::DaliException e) {
18862       {
18863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18864       };
18865     } catch (...) {
18866       {
18867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18868       };
18869     }
18870   }
18871
18872 }
18873
18874
18875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18876   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18877   SlotObserver *arg2 = (SlotObserver *) 0 ;
18878   CallbackBase *arg3 = (CallbackBase *) 0 ;
18879
18880   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18881   arg2 = (SlotObserver *)jarg2;
18882   arg3 = (CallbackBase *)jarg3;
18883   {
18884     try {
18885       (arg1)->SignalConnected(arg2,arg3);
18886     } catch (std::out_of_range& e) {
18887       {
18888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18889       };
18890     } catch (std::exception& e) {
18891       {
18892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18893       };
18894     } catch (Dali::DaliException e) {
18895       {
18896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18897       };
18898     } catch (...) {
18899       {
18900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18901       };
18902     }
18903   }
18904
18905 }
18906
18907
18908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18909   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18910
18911   arg1 = (Dali::SignalObserver *)jarg1;
18912   {
18913     try {
18914       delete arg1;
18915     } catch (std::out_of_range& e) {
18916       {
18917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18918       };
18919     } catch (std::exception& e) {
18920       {
18921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18922       };
18923     } catch (Dali::DaliException e) {
18924       {
18925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18926       };
18927     } catch (...) {
18928       {
18929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18930       };
18931     }
18932   }
18933
18934 }
18935
18936
18937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18938   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18939   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18940   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18941
18942   arg1 = (Dali::SignalObserver *)jarg1;
18943   arg2 = (Dali::SlotObserver *)jarg2;
18944   arg3 = (Dali::CallbackBase *)jarg3;
18945   {
18946     try {
18947       (arg1)->SignalDisconnected(arg2,arg3);
18948     } catch (std::out_of_range& e) {
18949       {
18950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18951       };
18952     } catch (std::exception& e) {
18953       {
18954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18955       };
18956     } catch (Dali::DaliException e) {
18957       {
18958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18959       };
18960     } catch (...) {
18961       {
18962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18963       };
18964     }
18965   }
18966
18967 }
18968
18969
18970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18971   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18972
18973   arg1 = (Dali::SlotObserver *)jarg1;
18974   {
18975     try {
18976       delete arg1;
18977     } catch (std::out_of_range& e) {
18978       {
18979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18980       };
18981     } catch (std::exception& e) {
18982       {
18983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18984       };
18985     } catch (Dali::DaliException e) {
18986       {
18987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18988       };
18989     } catch (...) {
18990       {
18991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18992       };
18993     }
18994   }
18995
18996 }
18997
18998
18999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19000   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19001   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19002
19003   arg1 = (Dali::SlotObserver *)jarg1;
19004   arg2 = (Dali::CallbackBase *)jarg2;
19005   {
19006     try {
19007       (arg1)->SlotDisconnected(arg2);
19008     } catch (std::out_of_range& e) {
19009       {
19010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19011       };
19012     } catch (std::exception& e) {
19013       {
19014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19015       };
19016     } catch (Dali::DaliException e) {
19017       {
19018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19019       };
19020     } catch (...) {
19021       {
19022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19023       };
19024     }
19025   }
19026
19027 }
19028
19029
19030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19031   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19032
19033   arg1 = (Dali::ConnectionTracker *)jarg1;
19034   {
19035     try {
19036       delete arg1;
19037     } catch (std::out_of_range& e) {
19038       {
19039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19040       };
19041     } catch (std::exception& e) {
19042       {
19043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19044       };
19045     } catch (Dali::DaliException e) {
19046       {
19047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19048       };
19049     } catch (...) {
19050       {
19051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19052       };
19053     }
19054   }
19055
19056 }
19057
19058
19059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19060   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19061
19062   arg1 = (Dali::ConnectionTracker *)jarg1;
19063   {
19064     try {
19065       (arg1)->DisconnectAll();
19066     } catch (std::out_of_range& e) {
19067       {
19068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19069       };
19070     } catch (std::exception& e) {
19071       {
19072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19073       };
19074     } catch (Dali::DaliException e) {
19075       {
19076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19077       };
19078     } catch (...) {
19079       {
19080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19081       };
19082     }
19083   }
19084
19085 }
19086
19087
19088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19089   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19090   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19091   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19092
19093   arg1 = (Dali::ConnectionTracker *)jarg1;
19094   arg2 = (Dali::SlotObserver *)jarg2;
19095   arg3 = (Dali::CallbackBase *)jarg3;
19096   {
19097     try {
19098       (arg1)->SignalConnected(arg2,arg3);
19099     } catch (std::out_of_range& e) {
19100       {
19101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19102       };
19103     } catch (std::exception& e) {
19104       {
19105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19106       };
19107     } catch (Dali::DaliException e) {
19108       {
19109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19110       };
19111     } catch (...) {
19112       {
19113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19114       };
19115     }
19116   }
19117
19118 }
19119
19120
19121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19122   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19123   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19124   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19125
19126   arg1 = (Dali::ConnectionTracker *)jarg1;
19127   arg2 = (Dali::SlotObserver *)jarg2;
19128   arg3 = (Dali::CallbackBase *)jarg3;
19129   {
19130     try {
19131       (arg1)->SignalDisconnected(arg2,arg3);
19132     } catch (std::out_of_range& e) {
19133       {
19134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19135       };
19136     } catch (std::exception& e) {
19137       {
19138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19139       };
19140     } catch (Dali::DaliException e) {
19141       {
19142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19143       };
19144     } catch (...) {
19145       {
19146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19147       };
19148     }
19149   }
19150
19151 }
19152
19153
19154 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19155   unsigned long jresult ;
19156   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19157   std::size_t result;
19158
19159   arg1 = (Dali::ConnectionTracker *)jarg1;
19160   {
19161     try {
19162       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19163     } catch (std::out_of_range& e) {
19164       {
19165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19166       };
19167     } catch (std::exception& e) {
19168       {
19169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19170       };
19171     } catch (Dali::DaliException e) {
19172       {
19173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19174       };
19175     } catch (...) {
19176       {
19177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19178       };
19179     }
19180   }
19181
19182   jresult = (unsigned long)result;
19183   return jresult;
19184 }
19185
19186
19187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19188   void * jresult ;
19189   Dali::ObjectRegistry *result = 0 ;
19190
19191   {
19192     try {
19193       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19194     } catch (std::out_of_range& e) {
19195       {
19196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19197       };
19198     } catch (std::exception& e) {
19199       {
19200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19201       };
19202     } catch (Dali::DaliException e) {
19203       {
19204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19205       };
19206     } catch (...) {
19207       {
19208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19209       };
19210     }
19211   }
19212
19213   jresult = (void *)result;
19214   return jresult;
19215 }
19216
19217
19218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19219   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19220
19221   arg1 = (Dali::ObjectRegistry *)jarg1;
19222   {
19223     try {
19224       delete arg1;
19225     } catch (std::out_of_range& e) {
19226       {
19227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19228       };
19229     } catch (std::exception& e) {
19230       {
19231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19232       };
19233     } catch (Dali::DaliException e) {
19234       {
19235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19236       };
19237     } catch (...) {
19238       {
19239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19240       };
19241     }
19242   }
19243
19244 }
19245
19246
19247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19248   void * jresult ;
19249   Dali::ObjectRegistry *arg1 = 0 ;
19250   Dali::ObjectRegistry *result = 0 ;
19251
19252   arg1 = (Dali::ObjectRegistry *)jarg1;
19253   if (!arg1) {
19254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19255     return 0;
19256   }
19257   {
19258     try {
19259       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19260     } catch (std::out_of_range& e) {
19261       {
19262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19263       };
19264     } catch (std::exception& e) {
19265       {
19266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19267       };
19268     } catch (Dali::DaliException e) {
19269       {
19270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19271       };
19272     } catch (...) {
19273       {
19274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19275       };
19276     }
19277   }
19278
19279   jresult = (void *)result;
19280   return jresult;
19281 }
19282
19283
19284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19285   void * jresult ;
19286   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19287   Dali::ObjectRegistry *arg2 = 0 ;
19288   Dali::ObjectRegistry *result = 0 ;
19289
19290   arg1 = (Dali::ObjectRegistry *)jarg1;
19291   arg2 = (Dali::ObjectRegistry *)jarg2;
19292   if (!arg2) {
19293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19294     return 0;
19295   }
19296   {
19297     try {
19298       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19299     } catch (std::out_of_range& e) {
19300       {
19301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19302       };
19303     } catch (std::exception& e) {
19304       {
19305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19306       };
19307     } catch (Dali::DaliException e) {
19308       {
19309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19310       };
19311     } catch (...) {
19312       {
19313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19314       };
19315     }
19316   }
19317
19318   jresult = (void *)result;
19319   return jresult;
19320 }
19321
19322
19323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19324   void * jresult ;
19325   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19326   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19327
19328   arg1 = (Dali::ObjectRegistry *)jarg1;
19329   {
19330     try {
19331       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19332     } catch (std::out_of_range& e) {
19333       {
19334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19335       };
19336     } catch (std::exception& e) {
19337       {
19338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19339       };
19340     } catch (Dali::DaliException e) {
19341       {
19342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19343       };
19344     } catch (...) {
19345       {
19346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19347       };
19348     }
19349   }
19350
19351   jresult = (void *)result;
19352   return jresult;
19353 }
19354
19355
19356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19357   void * jresult ;
19358   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19359   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19360
19361   arg1 = (Dali::ObjectRegistry *)jarg1;
19362   {
19363     try {
19364       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19365     } catch (std::out_of_range& e) {
19366       {
19367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19368       };
19369     } catch (std::exception& e) {
19370       {
19371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19372       };
19373     } catch (Dali::DaliException e) {
19374       {
19375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19376       };
19377     } catch (...) {
19378       {
19379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19380       };
19381     }
19382   }
19383
19384   jresult = (void *)result;
19385   return jresult;
19386 }
19387
19388
19389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19390   void * jresult ;
19391   Dali::PropertyCondition *result = 0 ;
19392
19393   {
19394     try {
19395       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19396     } catch (std::out_of_range& e) {
19397       {
19398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19399       };
19400     } catch (std::exception& e) {
19401       {
19402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19403       };
19404     } catch (Dali::DaliException e) {
19405       {
19406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19407       };
19408     } catch (...) {
19409       {
19410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19411       };
19412     }
19413   }
19414
19415   jresult = (void *)result;
19416   return jresult;
19417 }
19418
19419
19420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19421   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19422
19423   arg1 = (Dali::PropertyCondition *)jarg1;
19424   {
19425     try {
19426       delete arg1;
19427     } catch (std::out_of_range& e) {
19428       {
19429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19430       };
19431     } catch (std::exception& e) {
19432       {
19433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19434       };
19435     } catch (Dali::DaliException e) {
19436       {
19437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19438       };
19439     } catch (...) {
19440       {
19441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19442       };
19443     }
19444   }
19445
19446 }
19447
19448
19449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19450   void * jresult ;
19451   Dali::PropertyCondition *arg1 = 0 ;
19452   Dali::PropertyCondition *result = 0 ;
19453
19454   arg1 = (Dali::PropertyCondition *)jarg1;
19455   if (!arg1) {
19456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19457     return 0;
19458   }
19459   {
19460     try {
19461       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19462     } catch (std::out_of_range& e) {
19463       {
19464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19465       };
19466     } catch (std::exception& e) {
19467       {
19468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19469       };
19470     } catch (Dali::DaliException e) {
19471       {
19472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19473       };
19474     } catch (...) {
19475       {
19476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19477       };
19478     }
19479   }
19480
19481   jresult = (void *)result;
19482   return jresult;
19483 }
19484
19485
19486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19487   void * jresult ;
19488   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19489   Dali::PropertyCondition *arg2 = 0 ;
19490   Dali::PropertyCondition *result = 0 ;
19491
19492   arg1 = (Dali::PropertyCondition *)jarg1;
19493   arg2 = (Dali::PropertyCondition *)jarg2;
19494   if (!arg2) {
19495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19496     return 0;
19497   }
19498   {
19499     try {
19500       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19501     } catch (std::out_of_range& e) {
19502       {
19503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19504       };
19505     } catch (std::exception& e) {
19506       {
19507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19508       };
19509     } catch (Dali::DaliException e) {
19510       {
19511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19512       };
19513     } catch (...) {
19514       {
19515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19516       };
19517     }
19518   }
19519
19520   jresult = (void *)result;
19521   return jresult;
19522 }
19523
19524
19525 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19526   unsigned long jresult ;
19527   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19528   std::size_t result;
19529
19530   arg1 = (Dali::PropertyCondition *)jarg1;
19531   {
19532     try {
19533       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19534     } catch (std::out_of_range& e) {
19535       {
19536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19537       };
19538     } catch (std::exception& e) {
19539       {
19540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19541       };
19542     } catch (...) {
19543       {
19544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19545       };
19546     }
19547   }
19548   jresult = (unsigned long)result;
19549   return jresult;
19550 }
19551
19552
19553 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19554   float jresult ;
19555   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19556   std::size_t arg2 ;
19557   float result;
19558
19559   arg1 = (Dali::PropertyCondition *)jarg1;
19560   arg2 = (std::size_t)jarg2;
19561   {
19562     try {
19563       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19564     } catch (std::out_of_range& e) {
19565       {
19566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19567       };
19568     } catch (std::exception& e) {
19569       {
19570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19571       };
19572     } catch (...) {
19573       {
19574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19575       };
19576     }
19577   }
19578   jresult = result;
19579   return jresult;
19580 }
19581
19582
19583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19584   void * jresult ;
19585   float arg1 ;
19586   Dali::PropertyCondition result;
19587
19588   arg1 = (float)jarg1;
19589   {
19590     try {
19591       result = Dali::LessThanCondition(arg1);
19592     } catch (std::out_of_range& e) {
19593       {
19594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19595       };
19596     } catch (std::exception& e) {
19597       {
19598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19599       };
19600     } catch (Dali::DaliException e) {
19601       {
19602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19603       };
19604     } catch (...) {
19605       {
19606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19607       };
19608     }
19609   }
19610
19611   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19612   return jresult;
19613 }
19614
19615
19616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19617   void * jresult ;
19618   float arg1 ;
19619   Dali::PropertyCondition result;
19620
19621   arg1 = (float)jarg1;
19622   {
19623     try {
19624       result = Dali::GreaterThanCondition(arg1);
19625     } catch (std::out_of_range& e) {
19626       {
19627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19628       };
19629     } catch (std::exception& e) {
19630       {
19631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19632       };
19633     } catch (Dali::DaliException e) {
19634       {
19635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19636       };
19637     } catch (...) {
19638       {
19639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19640       };
19641     }
19642   }
19643
19644   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19645   return jresult;
19646 }
19647
19648
19649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19650   void * jresult ;
19651   float arg1 ;
19652   float arg2 ;
19653   Dali::PropertyCondition result;
19654
19655   arg1 = (float)jarg1;
19656   arg2 = (float)jarg2;
19657   {
19658     try {
19659       result = Dali::InsideCondition(arg1,arg2);
19660     } catch (std::out_of_range& e) {
19661       {
19662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19663       };
19664     } catch (std::exception& e) {
19665       {
19666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19667       };
19668     } catch (Dali::DaliException e) {
19669       {
19670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19671       };
19672     } catch (...) {
19673       {
19674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19675       };
19676     }
19677   }
19678
19679   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19680   return jresult;
19681 }
19682
19683
19684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19685   void * jresult ;
19686   float arg1 ;
19687   float arg2 ;
19688   Dali::PropertyCondition result;
19689
19690   arg1 = (float)jarg1;
19691   arg2 = (float)jarg2;
19692   {
19693     try {
19694       result = Dali::OutsideCondition(arg1,arg2);
19695     } catch (std::out_of_range& e) {
19696       {
19697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19698       };
19699     } catch (std::exception& e) {
19700       {
19701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19702       };
19703     } catch (Dali::DaliException e) {
19704       {
19705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19706       };
19707     } catch (...) {
19708       {
19709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19710       };
19711     }
19712   }
19713
19714   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19715   return jresult;
19716 }
19717
19718
19719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19720   void * jresult ;
19721   float arg1 ;
19722   float arg2 ;
19723   Dali::PropertyCondition result;
19724
19725   arg1 = (float)jarg1;
19726   arg2 = (float)jarg2;
19727   {
19728     try {
19729       result = Dali::StepCondition(arg1,arg2);
19730     } catch (std::out_of_range& e) {
19731       {
19732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19733       };
19734     } catch (std::exception& e) {
19735       {
19736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19737       };
19738     } catch (Dali::DaliException e) {
19739       {
19740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19741       };
19742     } catch (...) {
19743       {
19744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19745       };
19746     }
19747   }
19748
19749   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19750   return jresult;
19751 }
19752
19753
19754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19755   void * jresult ;
19756   float arg1 ;
19757   Dali::PropertyCondition result;
19758
19759   arg1 = (float)jarg1;
19760   {
19761     try {
19762       result = Dali::StepCondition(arg1);
19763     } catch (std::out_of_range& e) {
19764       {
19765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19766       };
19767     } catch (std::exception& e) {
19768       {
19769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19770       };
19771     } catch (Dali::DaliException e) {
19772       {
19773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19774       };
19775     } catch (...) {
19776       {
19777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19778       };
19779     }
19780   }
19781
19782   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19783   return jresult;
19784 }
19785
19786
19787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19788   void * jresult ;
19789   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19790   Dali::PropertyCondition result;
19791
19792   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19793   if (!arg1) {
19794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19795     return 0;
19796   }
19797   {
19798     try {
19799       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19800     } catch (std::out_of_range& e) {
19801       {
19802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19803       };
19804     } catch (std::exception& e) {
19805       {
19806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19807       };
19808     } catch (Dali::DaliException e) {
19809       {
19810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19811       };
19812     } catch (...) {
19813       {
19814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19815       };
19816     }
19817   }
19818
19819   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19820   return jresult;
19821 }
19822
19823
19824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19825   void * jresult ;
19826   Dali::PropertyNotification *result = 0 ;
19827
19828   {
19829     try {
19830       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19831     } catch (std::out_of_range& e) {
19832       {
19833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19834       };
19835     } catch (std::exception& e) {
19836       {
19837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19838       };
19839     } catch (Dali::DaliException e) {
19840       {
19841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19842       };
19843     } catch (...) {
19844       {
19845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19846       };
19847     }
19848   }
19849
19850   jresult = (void *)result;
19851   return jresult;
19852 }
19853
19854
19855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19856   void * jresult ;
19857   Dali::BaseHandle arg1 ;
19858   Dali::BaseHandle *argp1 ;
19859   Dali::PropertyNotification result;
19860
19861   argp1 = (Dali::BaseHandle *)jarg1;
19862   if (!argp1) {
19863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19864     return 0;
19865   }
19866   arg1 = *argp1;
19867   {
19868     try {
19869       result = Dali::PropertyNotification::DownCast(arg1);
19870     } catch (std::out_of_range& e) {
19871       {
19872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19873       };
19874     } catch (std::exception& e) {
19875       {
19876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19877       };
19878     } catch (Dali::DaliException e) {
19879       {
19880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19881       };
19882     } catch (...) {
19883       {
19884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19885       };
19886     }
19887   }
19888
19889   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19890   return jresult;
19891 }
19892
19893
19894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19895   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19896
19897   arg1 = (Dali::PropertyNotification *)jarg1;
19898   {
19899     try {
19900       delete arg1;
19901     } catch (std::out_of_range& e) {
19902       {
19903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19904       };
19905     } catch (std::exception& e) {
19906       {
19907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19908       };
19909     } catch (Dali::DaliException e) {
19910       {
19911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19912       };
19913     } catch (...) {
19914       {
19915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19916       };
19917     }
19918   }
19919
19920 }
19921
19922
19923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19924   void * jresult ;
19925   Dali::PropertyNotification *arg1 = 0 ;
19926   Dali::PropertyNotification *result = 0 ;
19927
19928   arg1 = (Dali::PropertyNotification *)jarg1;
19929   if (!arg1) {
19930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19931     return 0;
19932   }
19933   {
19934     try {
19935       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19936     } catch (std::out_of_range& e) {
19937       {
19938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19939       };
19940     } catch (std::exception& e) {
19941       {
19942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19943       };
19944     } catch (Dali::DaliException e) {
19945       {
19946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19947       };
19948     } catch (...) {
19949       {
19950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19951       };
19952     }
19953   }
19954
19955   jresult = (void *)result;
19956   return jresult;
19957 }
19958
19959
19960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19961   void * jresult ;
19962   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19963   Dali::PropertyNotification *arg2 = 0 ;
19964   Dali::PropertyNotification *result = 0 ;
19965
19966   arg1 = (Dali::PropertyNotification *)jarg1;
19967   arg2 = (Dali::PropertyNotification *)jarg2;
19968   if (!arg2) {
19969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19970     return 0;
19971   }
19972   {
19973     try {
19974       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19975     } catch (std::out_of_range& e) {
19976       {
19977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19978       };
19979     } catch (std::exception& e) {
19980       {
19981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19982       };
19983     } catch (Dali::DaliException e) {
19984       {
19985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19986       };
19987     } catch (...) {
19988       {
19989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19990       };
19991     }
19992   }
19993
19994   jresult = (void *)result;
19995   return jresult;
19996 }
19997
19998
19999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20000   void * jresult ;
20001   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20002   Dali::PropertyCondition result;
20003
20004   arg1 = (Dali::PropertyNotification *)jarg1;
20005   {
20006     try {
20007       result = (arg1)->GetCondition();
20008     } catch (std::out_of_range& e) {
20009       {
20010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20011       };
20012     } catch (std::exception& e) {
20013       {
20014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20015       };
20016     } catch (Dali::DaliException e) {
20017       {
20018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20019       };
20020     } catch (...) {
20021       {
20022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20023       };
20024     }
20025   }
20026
20027   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20028   return jresult;
20029 }
20030
20031
20032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20033   void * jresult ;
20034   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20035   Dali::Handle result;
20036
20037   arg1 = (Dali::PropertyNotification *)jarg1;
20038   {
20039     try {
20040       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20041     } catch (std::out_of_range& e) {
20042       {
20043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20044       };
20045     } catch (std::exception& e) {
20046       {
20047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20048       };
20049     } catch (Dali::DaliException e) {
20050       {
20051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20052       };
20053     } catch (...) {
20054       {
20055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20056       };
20057     }
20058   }
20059
20060   jresult = new Dali::Handle((const Dali::Handle &)result);
20061   return jresult;
20062 }
20063
20064
20065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20066   int jresult ;
20067   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20068   Dali::Property::Index result;
20069
20070   arg1 = (Dali::PropertyNotification *)jarg1;
20071   {
20072     try {
20073       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20074     } catch (std::out_of_range& e) {
20075       {
20076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20077       };
20078     } catch (std::exception& e) {
20079       {
20080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20081       };
20082     } catch (Dali::DaliException e) {
20083       {
20084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20085       };
20086     } catch (...) {
20087       {
20088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20089       };
20090     }
20091   }
20092
20093   jresult = result;
20094   return jresult;
20095 }
20096
20097
20098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20099   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20100   Dali::PropertyNotification::NotifyMode arg2 ;
20101
20102   arg1 = (Dali::PropertyNotification *)jarg1;
20103   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20104   {
20105     try {
20106       (arg1)->SetNotifyMode(arg2);
20107     } catch (std::out_of_range& e) {
20108       {
20109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20110       };
20111     } catch (std::exception& e) {
20112       {
20113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20114       };
20115     } catch (Dali::DaliException e) {
20116       {
20117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20118       };
20119     } catch (...) {
20120       {
20121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20122       };
20123     }
20124   }
20125
20126 }
20127
20128
20129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20130   int jresult ;
20131   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20132   Dali::PropertyNotification::NotifyMode result;
20133
20134   arg1 = (Dali::PropertyNotification *)jarg1;
20135   {
20136     try {
20137       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20138     } catch (std::out_of_range& e) {
20139       {
20140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20141       };
20142     } catch (std::exception& e) {
20143       {
20144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20145       };
20146     } catch (Dali::DaliException e) {
20147       {
20148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20149       };
20150     } catch (...) {
20151       {
20152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20153       };
20154     }
20155   }
20156
20157   jresult = (int)result;
20158   return jresult;
20159 }
20160
20161
20162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20163   unsigned int jresult ;
20164   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20165   bool result;
20166
20167   arg1 = (Dali::PropertyNotification *)jarg1;
20168   {
20169     try {
20170       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20171     } catch (std::out_of_range& e) {
20172       {
20173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20174       };
20175     } catch (std::exception& e) {
20176       {
20177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20178       };
20179     } catch (Dali::DaliException e) {
20180       {
20181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20182       };
20183     } catch (...) {
20184       {
20185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20186       };
20187     }
20188   }
20189
20190   jresult = result;
20191   return jresult;
20192 }
20193
20194
20195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20196   void * jresult ;
20197   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20198   Dali::PropertyNotifySignalType *result = 0 ;
20199
20200   arg1 = (Dali::PropertyNotification *)jarg1;
20201   {
20202     try {
20203       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20204     } catch (std::out_of_range& e) {
20205       {
20206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20207       };
20208     } catch (std::exception& e) {
20209       {
20210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20211       };
20212     } catch (Dali::DaliException e) {
20213       {
20214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20215       };
20216     } catch (...) {
20217       {
20218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20219       };
20220     }
20221   }
20222
20223   jresult = (void *)result;
20224   return jresult;
20225 }
20226
20227
20228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20229   void * jresult ;
20230   Dali::Handle *result = 0 ;
20231
20232   {
20233     try {
20234       result = (Dali::Handle *)new Dali::Handle();
20235     } catch (std::out_of_range& e) {
20236       {
20237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20238       };
20239     } catch (std::exception& e) {
20240       {
20241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20242       };
20243     } catch (Dali::DaliException e) {
20244       {
20245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20246       };
20247     } catch (...) {
20248       {
20249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20250       };
20251     }
20252   }
20253
20254   jresult = (void *)result;
20255   return jresult;
20256 }
20257
20258
20259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20260   void * jresult ;
20261   Dali::Handle result;
20262
20263   {
20264     try {
20265       result = Dali::Handle::New();
20266     } catch (std::out_of_range& e) {
20267       {
20268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20269       };
20270     } catch (std::exception& e) {
20271       {
20272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20273       };
20274     } catch (Dali::DaliException e) {
20275       {
20276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20277       };
20278     } catch (...) {
20279       {
20280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20281       };
20282     }
20283   }
20284
20285   jresult = new Dali::Handle((const Dali::Handle &)result);
20286   return jresult;
20287 }
20288
20289
20290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20291   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20292
20293   arg1 = (Dali::Handle *)jarg1;
20294   {
20295     try {
20296       delete arg1;
20297     } catch (std::out_of_range& e) {
20298       {
20299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20300       };
20301     } catch (std::exception& e) {
20302       {
20303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20304       };
20305     } catch (Dali::DaliException e) {
20306       {
20307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20308       };
20309     } catch (...) {
20310       {
20311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20312       };
20313     }
20314   }
20315
20316 }
20317
20318
20319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20320   void * jresult ;
20321   Dali::Handle *arg1 = 0 ;
20322   Dali::Handle *result = 0 ;
20323
20324   arg1 = (Dali::Handle *)jarg1;
20325   if (!arg1) {
20326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20327     return 0;
20328   }
20329   {
20330     try {
20331       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20332     } catch (std::out_of_range& e) {
20333       {
20334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20335       };
20336     } catch (std::exception& e) {
20337       {
20338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20339       };
20340     } catch (Dali::DaliException e) {
20341       {
20342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20343       };
20344     } catch (...) {
20345       {
20346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20347       };
20348     }
20349   }
20350
20351   jresult = (void *)result;
20352   return jresult;
20353 }
20354
20355
20356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20357   void * jresult ;
20358   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20359   Dali::Handle *arg2 = 0 ;
20360   Dali::Handle *result = 0 ;
20361
20362   arg1 = (Dali::Handle *)jarg1;
20363   arg2 = (Dali::Handle *)jarg2;
20364   if (!arg2) {
20365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20366     return 0;
20367   }
20368   {
20369     try {
20370       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20371     } catch (std::out_of_range& e) {
20372       {
20373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20374       };
20375     } catch (std::exception& e) {
20376       {
20377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20378       };
20379     } catch (Dali::DaliException e) {
20380       {
20381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20382       };
20383     } catch (...) {
20384       {
20385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20386       };
20387     }
20388   }
20389
20390   jresult = (void *)result;
20391   return jresult;
20392 }
20393
20394
20395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20396   void * jresult ;
20397   Dali::BaseHandle arg1 ;
20398   Dali::BaseHandle *argp1 ;
20399   Dali::Handle result;
20400
20401   argp1 = (Dali::BaseHandle *)jarg1;
20402   if (!argp1) {
20403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20404     return 0;
20405   }
20406   arg1 = *argp1;
20407   {
20408     try {
20409       result = Dali::Handle::DownCast(arg1);
20410     } catch (std::out_of_range& e) {
20411       {
20412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20413       };
20414     } catch (std::exception& e) {
20415       {
20416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20417       };
20418     } catch (Dali::DaliException e) {
20419       {
20420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20421       };
20422     } catch (...) {
20423       {
20424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20425       };
20426     }
20427   }
20428
20429   jresult = new Dali::Handle((const Dali::Handle &)result);
20430   return jresult;
20431 }
20432
20433
20434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20435   unsigned int jresult ;
20436   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20437   Dali::Handle::Capability arg2 ;
20438   bool result;
20439
20440   arg1 = (Dali::Handle *)jarg1;
20441   arg2 = (Dali::Handle::Capability)jarg2;
20442   {
20443     try {
20444       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20445     } catch (std::out_of_range& e) {
20446       {
20447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20448       };
20449     } catch (std::exception& e) {
20450       {
20451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20452       };
20453     } catch (Dali::DaliException e) {
20454       {
20455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20456       };
20457     } catch (...) {
20458       {
20459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20460       };
20461     }
20462   }
20463
20464   jresult = result;
20465   return jresult;
20466 }
20467
20468
20469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20470   unsigned int jresult ;
20471   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20472   unsigned int result;
20473
20474   arg1 = (Dali::Handle *)jarg1;
20475   {
20476     try {
20477       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20478     } catch (std::out_of_range& e) {
20479       {
20480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20481       };
20482     } catch (std::exception& e) {
20483       {
20484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20485       };
20486     } catch (Dali::DaliException e) {
20487       {
20488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20489       };
20490     } catch (...) {
20491       {
20492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20493       };
20494     }
20495   }
20496
20497   jresult = result;
20498   return jresult;
20499 }
20500
20501
20502 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20503   char * jresult ;
20504   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20505   Dali::Property::Index arg2 ;
20506   std::string result;
20507
20508   arg1 = (Dali::Handle *)jarg1;
20509   arg2 = (Dali::Property::Index)jarg2;
20510   {
20511     try {
20512       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20513     } catch (std::out_of_range& e) {
20514       {
20515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20516       };
20517     } catch (std::exception& e) {
20518       {
20519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20520       };
20521     } catch (Dali::DaliException e) {
20522       {
20523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20524       };
20525     } catch (...) {
20526       {
20527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20528       };
20529     }
20530   }
20531
20532   jresult = SWIG_csharp_string_callback((&result)->c_str());
20533   return jresult;
20534 }
20535
20536
20537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20538   int jresult ;
20539   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20540   std::string *arg2 = 0 ;
20541   Dali::Property::Index result;
20542
20543   arg1 = (Dali::Handle *)jarg1;
20544   if (!jarg2) {
20545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20546     return 0;
20547   }
20548   std::string arg2_str(jarg2);
20549   arg2 = &arg2_str;
20550   {
20551     try {
20552       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20553     } catch (std::out_of_range& e) {
20554       {
20555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20556       };
20557     } catch (std::exception& e) {
20558       {
20559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20560       };
20561     } catch (Dali::DaliException e) {
20562       {
20563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20564       };
20565     } catch (...) {
20566       {
20567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20568       };
20569     }
20570   }
20571
20572   jresult = result;
20573
20574   //argout typemap for const std::string&
20575
20576   return jresult;
20577 }
20578
20579
20580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20581   unsigned int jresult ;
20582   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20583   Dali::Property::Index arg2 ;
20584   bool result;
20585
20586   arg1 = (Dali::Handle *)jarg1;
20587   arg2 = (Dali::Property::Index)jarg2;
20588   {
20589     try {
20590       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20591     } catch (std::out_of_range& e) {
20592       {
20593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20594       };
20595     } catch (std::exception& e) {
20596       {
20597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20598       };
20599     } catch (Dali::DaliException e) {
20600       {
20601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20602       };
20603     } catch (...) {
20604       {
20605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20606       };
20607     }
20608   }
20609
20610   jresult = result;
20611   return jresult;
20612 }
20613
20614
20615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20616   unsigned int jresult ;
20617   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20618   Dali::Property::Index arg2 ;
20619   bool result;
20620
20621   arg1 = (Dali::Handle *)jarg1;
20622   arg2 = (Dali::Property::Index)jarg2;
20623   {
20624     try {
20625       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20626     } catch (std::out_of_range& e) {
20627       {
20628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20629       };
20630     } catch (std::exception& e) {
20631       {
20632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20633       };
20634     } catch (Dali::DaliException e) {
20635       {
20636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20637       };
20638     } catch (...) {
20639       {
20640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20641       };
20642     }
20643   }
20644
20645   jresult = result;
20646   return jresult;
20647 }
20648
20649
20650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20651   unsigned int jresult ;
20652   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20653   Dali::Property::Index arg2 ;
20654   bool result;
20655
20656   arg1 = (Dali::Handle *)jarg1;
20657   arg2 = (Dali::Property::Index)jarg2;
20658   {
20659     try {
20660       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20661     } catch (std::out_of_range& e) {
20662       {
20663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20664       };
20665     } catch (std::exception& e) {
20666       {
20667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20668       };
20669     } catch (Dali::DaliException e) {
20670       {
20671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20672       };
20673     } catch (...) {
20674       {
20675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20676       };
20677     }
20678   }
20679
20680   jresult = result;
20681   return jresult;
20682 }
20683
20684
20685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20686   int jresult ;
20687   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20688   Dali::Property::Index arg2 ;
20689   Dali::Property::Type result;
20690
20691   arg1 = (Dali::Handle *)jarg1;
20692   arg2 = (Dali::Property::Index)jarg2;
20693   {
20694     try {
20695       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20696     } catch (std::out_of_range& e) {
20697       {
20698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20699       };
20700     } catch (std::exception& e) {
20701       {
20702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20703       };
20704     } catch (Dali::DaliException e) {
20705       {
20706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20707       };
20708     } catch (...) {
20709       {
20710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20711       };
20712     }
20713   }
20714
20715   jresult = (int)result;
20716   return jresult;
20717 }
20718
20719
20720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20721   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20722   Dali::Property::Index arg2 ;
20723   Dali::Property::Value *arg3 = 0 ;
20724
20725   arg1 = (Dali::Handle *)jarg1;
20726   arg2 = (Dali::Property::Index)jarg2;
20727   arg3 = (Dali::Property::Value *)jarg3;
20728   if (!arg3) {
20729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20730     return ;
20731   }
20732   {
20733     try {
20734       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20735     } catch (std::out_of_range& e) {
20736       {
20737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20738       };
20739     } catch (std::exception& e) {
20740       {
20741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20742       };
20743     } catch (Dali::DaliException e) {
20744       {
20745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20746       };
20747     } catch (...) {
20748       {
20749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20750       };
20751     }
20752   }
20753
20754 }
20755
20756
20757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20758   int jresult ;
20759   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20760   std::string *arg2 = 0 ;
20761   Dali::Property::Value *arg3 = 0 ;
20762   Dali::Property::Index result;
20763
20764   arg1 = (Dali::Handle *)jarg1;
20765   if (!jarg2) {
20766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20767     return 0;
20768   }
20769   std::string arg2_str(jarg2);
20770   arg2 = &arg2_str;
20771   arg3 = (Dali::Property::Value *)jarg3;
20772   if (!arg3) {
20773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20774     return 0;
20775   }
20776   {
20777     try {
20778       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20779     } catch (std::out_of_range& e) {
20780       {
20781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20782       };
20783     } catch (std::exception& e) {
20784       {
20785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20786       };
20787     } catch (Dali::DaliException e) {
20788       {
20789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20790       };
20791     } catch (...) {
20792       {
20793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20794       };
20795     }
20796   }
20797
20798   jresult = result;
20799
20800   //argout typemap for const std::string&
20801
20802   return jresult;
20803 }
20804
20805
20806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20807   int jresult ;
20808   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20809   std::string *arg2 = 0 ;
20810   Dali::Property::Value *arg3 = 0 ;
20811   Dali::Property::AccessMode arg4 ;
20812   Dali::Property::Index result;
20813
20814   arg1 = (Dali::Handle *)jarg1;
20815   if (!jarg2) {
20816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20817     return 0;
20818   }
20819   std::string arg2_str(jarg2);
20820   arg2 = &arg2_str;
20821   arg3 = (Dali::Property::Value *)jarg3;
20822   if (!arg3) {
20823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20824     return 0;
20825   }
20826   arg4 = (Dali::Property::AccessMode)jarg4;
20827   {
20828     try {
20829       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20830     } catch (std::out_of_range& e) {
20831       {
20832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20833       };
20834     } catch (std::exception& e) {
20835       {
20836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20837       };
20838     } catch (Dali::DaliException e) {
20839       {
20840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20841       };
20842     } catch (...) {
20843       {
20844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20845       };
20846     }
20847   }
20848
20849   jresult = result;
20850
20851   //argout typemap for const std::string&
20852
20853   return jresult;
20854 }
20855
20856
20857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20858   void * jresult ;
20859   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20860   Dali::Property::Index arg2 ;
20861   Dali::Property::Value result;
20862
20863   arg1 = (Dali::Handle *)jarg1;
20864   arg2 = (Dali::Property::Index)jarg2;
20865   {
20866     try {
20867       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20868     } catch (std::out_of_range& e) {
20869       {
20870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20871       };
20872     } catch (std::exception& e) {
20873       {
20874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20875       };
20876     } catch (Dali::DaliException e) {
20877       {
20878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20879       };
20880     } catch (...) {
20881       {
20882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20883       };
20884     }
20885   }
20886
20887   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20888   return jresult;
20889 }
20890
20891
20892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20893   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20894   Dali::Property::IndexContainer *arg2 = 0 ;
20895
20896   arg1 = (Dali::Handle *)jarg1;
20897   arg2 = (Dali::Property::IndexContainer *)jarg2;
20898   if (!arg2) {
20899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20900     return ;
20901   }
20902   {
20903     try {
20904       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20905     } catch (std::out_of_range& e) {
20906       {
20907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20908       };
20909     } catch (std::exception& e) {
20910       {
20911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20912       };
20913     } catch (Dali::DaliException e) {
20914       {
20915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20916       };
20917     } catch (...) {
20918       {
20919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20920       };
20921     }
20922   }
20923
20924 }
20925
20926
20927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20928   void * jresult ;
20929   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20930   Dali::Property::Index arg2 ;
20931   Dali::PropertyCondition *arg3 = 0 ;
20932   Dali::PropertyNotification result;
20933
20934   arg1 = (Dali::Handle *)jarg1;
20935   arg2 = (Dali::Property::Index)jarg2;
20936   arg3 = (Dali::PropertyCondition *)jarg3;
20937   if (!arg3) {
20938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20939     return 0;
20940   }
20941   {
20942     try {
20943       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20944     } catch (std::out_of_range& e) {
20945       {
20946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20947       };
20948     } catch (std::exception& e) {
20949       {
20950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20951       };
20952     } catch (Dali::DaliException e) {
20953       {
20954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20955       };
20956     } catch (...) {
20957       {
20958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20959       };
20960     }
20961   }
20962
20963   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20964   return jresult;
20965 }
20966
20967
20968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20969   void * jresult ;
20970   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20971   Dali::Property::Index arg2 ;
20972   int arg3 ;
20973   Dali::PropertyCondition *arg4 = 0 ;
20974   Dali::PropertyNotification result;
20975
20976   arg1 = (Dali::Handle *)jarg1;
20977   arg2 = (Dali::Property::Index)jarg2;
20978   arg3 = (int)jarg3;
20979   arg4 = (Dali::PropertyCondition *)jarg4;
20980   if (!arg4) {
20981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20982     return 0;
20983   }
20984   {
20985     try {
20986       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20987     } catch (std::out_of_range& e) {
20988       {
20989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20990       };
20991     } catch (std::exception& e) {
20992       {
20993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20994       };
20995     } catch (Dali::DaliException e) {
20996       {
20997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20998       };
20999     } catch (...) {
21000       {
21001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21002       };
21003     }
21004   }
21005
21006   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21007   return jresult;
21008 }
21009
21010
21011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21012   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21013   Dali::PropertyNotification arg2 ;
21014   Dali::PropertyNotification *argp2 ;
21015
21016   arg1 = (Dali::Handle *)jarg1;
21017   argp2 = (Dali::PropertyNotification *)jarg2;
21018   if (!argp2) {
21019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21020     return ;
21021   }
21022   arg2 = *argp2;
21023   {
21024     try {
21025       (arg1)->RemovePropertyNotification(arg2);
21026     } catch (std::out_of_range& e) {
21027       {
21028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21029       };
21030     } catch (std::exception& e) {
21031       {
21032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21033       };
21034     } catch (Dali::DaliException e) {
21035       {
21036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21037       };
21038     } catch (...) {
21039       {
21040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21041       };
21042     }
21043   }
21044
21045 }
21046
21047
21048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21049   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21050
21051   arg1 = (Dali::Handle *)jarg1;
21052   {
21053     try {
21054       (arg1)->RemovePropertyNotifications();
21055     } catch (std::out_of_range& e) {
21056       {
21057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21058       };
21059     } catch (std::exception& e) {
21060       {
21061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21062       };
21063     } catch (Dali::DaliException e) {
21064       {
21065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21066       };
21067     } catch (...) {
21068       {
21069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21070       };
21071     }
21072   }
21073
21074 }
21075
21076
21077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21078   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21079
21080   arg1 = (Dali::Handle *)jarg1;
21081   {
21082     try {
21083       (arg1)->RemoveConstraints();
21084     } catch (std::out_of_range& e) {
21085       {
21086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21087       };
21088     } catch (std::exception& e) {
21089       {
21090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21091       };
21092     } catch (Dali::DaliException e) {
21093       {
21094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21095       };
21096     } catch (...) {
21097       {
21098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21099       };
21100     }
21101   }
21102
21103 }
21104
21105
21106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21107   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21108   unsigned int arg2 ;
21109
21110   arg1 = (Dali::Handle *)jarg1;
21111   arg2 = (unsigned int)jarg2;
21112   {
21113     try {
21114       (arg1)->RemoveConstraints(arg2);
21115     } catch (std::out_of_range& e) {
21116       {
21117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21118       };
21119     } catch (std::exception& e) {
21120       {
21121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21122       };
21123     } catch (Dali::DaliException e) {
21124       {
21125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21126       };
21127     } catch (...) {
21128       {
21129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21130       };
21131     }
21132   }
21133
21134 }
21135
21136
21137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21138   int jresult ;
21139   Dali::Property::Index result;
21140
21141   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21142   jresult = result;
21143   return jresult;
21144 }
21145
21146
21147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21148   void * jresult ;
21149   Dali::Handle result;
21150
21151   {
21152     try {
21153       result = Dali::WeightObject::New();
21154     } catch (std::out_of_range& e) {
21155       {
21156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21157       };
21158     } catch (std::exception& e) {
21159       {
21160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21161       };
21162     } catch (Dali::DaliException e) {
21163       {
21164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21165       };
21166     } catch (...) {
21167       {
21168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21169       };
21170     }
21171   }
21172
21173   jresult = new Dali::Handle((const Dali::Handle &)result);
21174   return jresult;
21175 }
21176
21177
21178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21179   void * jresult ;
21180   Dali::TypeInfo *result = 0 ;
21181
21182   {
21183     try {
21184       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21185     } catch (std::out_of_range& e) {
21186       {
21187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21188       };
21189     } catch (std::exception& e) {
21190       {
21191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21192       };
21193     } catch (Dali::DaliException e) {
21194       {
21195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21196       };
21197     } catch (...) {
21198       {
21199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21200       };
21201     }
21202   }
21203
21204   jresult = (void *)result;
21205   return jresult;
21206 }
21207
21208
21209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21210   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21211
21212   arg1 = (Dali::TypeInfo *)jarg1;
21213   {
21214     try {
21215       delete arg1;
21216     } catch (std::out_of_range& e) {
21217       {
21218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21219       };
21220     } catch (std::exception& e) {
21221       {
21222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21223       };
21224     } catch (Dali::DaliException e) {
21225       {
21226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21227       };
21228     } catch (...) {
21229       {
21230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21231       };
21232     }
21233   }
21234
21235 }
21236
21237
21238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21239   void * jresult ;
21240   Dali::TypeInfo *arg1 = 0 ;
21241   Dali::TypeInfo *result = 0 ;
21242
21243   arg1 = (Dali::TypeInfo *)jarg1;
21244   if (!arg1) {
21245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21246     return 0;
21247   }
21248   {
21249     try {
21250       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21251     } catch (std::out_of_range& e) {
21252       {
21253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21254       };
21255     } catch (std::exception& e) {
21256       {
21257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21258       };
21259     } catch (Dali::DaliException e) {
21260       {
21261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21262       };
21263     } catch (...) {
21264       {
21265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21266       };
21267     }
21268   }
21269
21270   jresult = (void *)result;
21271   return jresult;
21272 }
21273
21274
21275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21276   void * jresult ;
21277   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21278   Dali::TypeInfo *arg2 = 0 ;
21279   Dali::TypeInfo *result = 0 ;
21280
21281   arg1 = (Dali::TypeInfo *)jarg1;
21282   arg2 = (Dali::TypeInfo *)jarg2;
21283   if (!arg2) {
21284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21285     return 0;
21286   }
21287   {
21288     try {
21289       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21290     } catch (std::out_of_range& e) {
21291       {
21292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21293       };
21294     } catch (std::exception& e) {
21295       {
21296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21297       };
21298     } catch (Dali::DaliException e) {
21299       {
21300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21301       };
21302     } catch (...) {
21303       {
21304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21305       };
21306     }
21307   }
21308
21309   jresult = (void *)result;
21310   return jresult;
21311 }
21312
21313
21314 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21315   char * jresult ;
21316   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21317   std::string *result = 0 ;
21318
21319   arg1 = (Dali::TypeInfo *)jarg1;
21320   {
21321     try {
21322       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21323     } catch (std::out_of_range& e) {
21324       {
21325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21326       };
21327     } catch (std::exception& e) {
21328       {
21329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21330       };
21331     } catch (Dali::DaliException e) {
21332       {
21333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21334       };
21335     } catch (...) {
21336       {
21337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21338       };
21339     }
21340   }
21341
21342   jresult = SWIG_csharp_string_callback(result->c_str());
21343   return jresult;
21344 }
21345
21346
21347 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21348   char * jresult ;
21349   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21350   std::string *result = 0 ;
21351
21352   arg1 = (Dali::TypeInfo *)jarg1;
21353   {
21354     try {
21355       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21356     } catch (std::out_of_range& e) {
21357       {
21358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21359       };
21360     } catch (std::exception& e) {
21361       {
21362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21363       };
21364     } catch (Dali::DaliException e) {
21365       {
21366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21367       };
21368     } catch (...) {
21369       {
21370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21371       };
21372     }
21373   }
21374
21375   jresult = SWIG_csharp_string_callback(result->c_str());
21376   return jresult;
21377 }
21378
21379
21380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21381   void * jresult ;
21382   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21383   Dali::BaseHandle result;
21384
21385   arg1 = (Dali::TypeInfo *)jarg1;
21386   {
21387     try {
21388       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21389     } catch (std::out_of_range& e) {
21390       {
21391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21392       };
21393     } catch (std::exception& e) {
21394       {
21395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21396       };
21397     } catch (Dali::DaliException e) {
21398       {
21399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21400       };
21401     } catch (...) {
21402       {
21403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21404       };
21405     }
21406   }
21407
21408   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21409   return jresult;
21410 }
21411
21412
21413 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21414   unsigned long jresult ;
21415   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21416   size_t result;
21417
21418   arg1 = (Dali::TypeInfo *)jarg1;
21419   {
21420     try {
21421       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21422     } catch (std::out_of_range& e) {
21423       {
21424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21425       };
21426     } catch (std::exception& e) {
21427       {
21428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21429       };
21430     } catch (Dali::DaliException e) {
21431       {
21432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21433       };
21434     } catch (...) {
21435       {
21436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21437       };
21438     }
21439   }
21440
21441   jresult = (unsigned long)result;
21442   return jresult;
21443 }
21444
21445
21446 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21447   char * jresult ;
21448   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21449   size_t arg2 ;
21450   std::string result;
21451
21452   arg1 = (Dali::TypeInfo *)jarg1;
21453   arg2 = (size_t)jarg2;
21454   {
21455     try {
21456       result = (arg1)->GetActionName(arg2);
21457     } catch (std::out_of_range& e) {
21458       {
21459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21460       };
21461     } catch (std::exception& e) {
21462       {
21463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21464       };
21465     } catch (Dali::DaliException e) {
21466       {
21467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21468       };
21469     } catch (...) {
21470       {
21471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21472       };
21473     }
21474   }
21475
21476   jresult = SWIG_csharp_string_callback((&result)->c_str());
21477   return jresult;
21478 }
21479
21480
21481 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21482   unsigned long jresult ;
21483   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21484   size_t result;
21485
21486   arg1 = (Dali::TypeInfo *)jarg1;
21487   {
21488     try {
21489       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21490     } catch (std::out_of_range& e) {
21491       {
21492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21493       };
21494     } catch (std::exception& e) {
21495       {
21496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21497       };
21498     } catch (Dali::DaliException e) {
21499       {
21500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21501       };
21502     } catch (...) {
21503       {
21504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21505       };
21506     }
21507   }
21508
21509   jresult = (unsigned long)result;
21510   return jresult;
21511 }
21512
21513
21514 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21515   char * jresult ;
21516   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21517   size_t arg2 ;
21518   std::string result;
21519
21520   arg1 = (Dali::TypeInfo *)jarg1;
21521   arg2 = (size_t)jarg2;
21522   {
21523     try {
21524       result = (arg1)->GetSignalName(arg2);
21525     } catch (std::out_of_range& e) {
21526       {
21527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21528       };
21529     } catch (std::exception& e) {
21530       {
21531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21532       };
21533     } catch (Dali::DaliException e) {
21534       {
21535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21536       };
21537     } catch (...) {
21538       {
21539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21540       };
21541     }
21542   }
21543
21544   jresult = SWIG_csharp_string_callback((&result)->c_str());
21545   return jresult;
21546 }
21547
21548
21549 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21550   unsigned long jresult ;
21551   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21552   size_t result;
21553
21554   arg1 = (Dali::TypeInfo *)jarg1;
21555   {
21556     try {
21557       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21558     } catch (std::out_of_range& e) {
21559       {
21560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21561       };
21562     } catch (std::exception& e) {
21563       {
21564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21565       };
21566     } catch (Dali::DaliException e) {
21567       {
21568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21569       };
21570     } catch (...) {
21571       {
21572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21573       };
21574     }
21575   }
21576
21577   jresult = (unsigned long)result;
21578   return jresult;
21579 }
21580
21581
21582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21583   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21584   Dali::Property::IndexContainer *arg2 = 0 ;
21585
21586   arg1 = (Dali::TypeInfo *)jarg1;
21587   arg2 = (Dali::Property::IndexContainer *)jarg2;
21588   if (!arg2) {
21589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21590     return ;
21591   }
21592   {
21593     try {
21594       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21595     } catch (std::out_of_range& e) {
21596       {
21597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21598       };
21599     } catch (std::exception& e) {
21600       {
21601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21602       };
21603     } catch (Dali::DaliException e) {
21604       {
21605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21606       };
21607     } catch (...) {
21608       {
21609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21610       };
21611     }
21612   }
21613
21614 }
21615
21616
21617 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21618   char * jresult ;
21619   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21620   Dali::Property::Index arg2 ;
21621   std::string *result = 0 ;
21622
21623   arg1 = (Dali::TypeInfo *)jarg1;
21624   arg2 = (Dali::Property::Index)jarg2;
21625   {
21626     try {
21627       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21628     } catch (std::out_of_range& e) {
21629       {
21630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21631       };
21632     } catch (std::exception& e) {
21633       {
21634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21635       };
21636     } catch (Dali::DaliException e) {
21637       {
21638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21639       };
21640     } catch (...) {
21641       {
21642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21643       };
21644     }
21645   }
21646
21647   jresult = SWIG_csharp_string_callback(result->c_str());
21648   return jresult;
21649 }
21650
21651
21652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21653   void * jresult ;
21654   Dali::TypeRegistry result;
21655
21656   {
21657     try {
21658       result = Dali::TypeRegistry::Get();
21659     } catch (std::out_of_range& e) {
21660       {
21661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21662       };
21663     } catch (std::exception& e) {
21664       {
21665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21666       };
21667     } catch (Dali::DaliException e) {
21668       {
21669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21670       };
21671     } catch (...) {
21672       {
21673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21674       };
21675     }
21676   }
21677
21678   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21679   return jresult;
21680 }
21681
21682
21683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21684   void * jresult ;
21685   Dali::TypeRegistry *result = 0 ;
21686
21687   {
21688     try {
21689       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21690     } catch (std::out_of_range& e) {
21691       {
21692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21693       };
21694     } catch (std::exception& e) {
21695       {
21696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21697       };
21698     } catch (Dali::DaliException e) {
21699       {
21700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21701       };
21702     } catch (...) {
21703       {
21704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21705       };
21706     }
21707   }
21708
21709   jresult = (void *)result;
21710   return jresult;
21711 }
21712
21713
21714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21715   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21716
21717   arg1 = (Dali::TypeRegistry *)jarg1;
21718   {
21719     try {
21720       delete arg1;
21721     } catch (std::out_of_range& e) {
21722       {
21723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21724       };
21725     } catch (std::exception& e) {
21726       {
21727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21728       };
21729     } catch (Dali::DaliException e) {
21730       {
21731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21732       };
21733     } catch (...) {
21734       {
21735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21736       };
21737     }
21738   }
21739
21740 }
21741
21742
21743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21744   void * jresult ;
21745   Dali::TypeRegistry *arg1 = 0 ;
21746   Dali::TypeRegistry *result = 0 ;
21747
21748   arg1 = (Dali::TypeRegistry *)jarg1;
21749   if (!arg1) {
21750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21751     return 0;
21752   }
21753   {
21754     try {
21755       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21756     } catch (std::out_of_range& e) {
21757       {
21758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21759       };
21760     } catch (std::exception& e) {
21761       {
21762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21763       };
21764     } catch (Dali::DaliException e) {
21765       {
21766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21767       };
21768     } catch (...) {
21769       {
21770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21771       };
21772     }
21773   }
21774
21775   jresult = (void *)result;
21776   return jresult;
21777 }
21778
21779
21780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21781   void * jresult ;
21782   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21783   Dali::TypeRegistry *arg2 = 0 ;
21784   Dali::TypeRegistry *result = 0 ;
21785
21786   arg1 = (Dali::TypeRegistry *)jarg1;
21787   arg2 = (Dali::TypeRegistry *)jarg2;
21788   if (!arg2) {
21789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21790     return 0;
21791   }
21792   {
21793     try {
21794       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21795     } catch (std::out_of_range& e) {
21796       {
21797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21798       };
21799     } catch (std::exception& e) {
21800       {
21801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21802       };
21803     } catch (Dali::DaliException e) {
21804       {
21805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21806       };
21807     } catch (...) {
21808       {
21809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21810       };
21811     }
21812   }
21813
21814   jresult = (void *)result;
21815   return jresult;
21816 }
21817
21818
21819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21820   void * jresult ;
21821   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21822   std::string *arg2 = 0 ;
21823   Dali::TypeInfo result;
21824
21825   arg1 = (Dali::TypeRegistry *)jarg1;
21826   if (!jarg2) {
21827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21828     return 0;
21829   }
21830   std::string arg2_str(jarg2);
21831   arg2 = &arg2_str;
21832   {
21833     try {
21834       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21835     } catch (std::out_of_range& e) {
21836       {
21837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21838       };
21839     } catch (std::exception& e) {
21840       {
21841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21842       };
21843     } catch (Dali::DaliException e) {
21844       {
21845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21846       };
21847     } catch (...) {
21848       {
21849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21850       };
21851     }
21852   }
21853
21854   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21855
21856   //argout typemap for const std::string&
21857
21858   return jresult;
21859 }
21860
21861
21862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21863   void * jresult ;
21864   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21865   std::type_info *arg2 = 0 ;
21866   Dali::TypeInfo result;
21867
21868   arg1 = (Dali::TypeRegistry *)jarg1;
21869   arg2 = (std::type_info *)jarg2;
21870   if (!arg2) {
21871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21872     return 0;
21873   }
21874   {
21875     try {
21876       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21877     } catch (std::out_of_range& e) {
21878       {
21879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21880       };
21881     } catch (std::exception& e) {
21882       {
21883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21884       };
21885     } catch (Dali::DaliException e) {
21886       {
21887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21888       };
21889     } catch (...) {
21890       {
21891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21892       };
21893     }
21894   }
21895
21896   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21897   return jresult;
21898 }
21899
21900
21901 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21902   unsigned long jresult ;
21903   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21904   size_t result;
21905
21906   arg1 = (Dali::TypeRegistry *)jarg1;
21907   {
21908     try {
21909       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21910     } catch (std::out_of_range& e) {
21911       {
21912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21913       };
21914     } catch (std::exception& e) {
21915       {
21916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21917       };
21918     } catch (Dali::DaliException e) {
21919       {
21920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21921       };
21922     } catch (...) {
21923       {
21924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21925       };
21926     }
21927   }
21928
21929   jresult = (unsigned long)result;
21930   return jresult;
21931 }
21932
21933
21934 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21935   char * jresult ;
21936   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21937   size_t arg2 ;
21938   std::string result;
21939
21940   arg1 = (Dali::TypeRegistry *)jarg1;
21941   arg2 = (size_t)jarg2;
21942   {
21943     try {
21944       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21945     } catch (std::out_of_range& e) {
21946       {
21947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21948       };
21949     } catch (std::exception& e) {
21950       {
21951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21952       };
21953     } catch (Dali::DaliException e) {
21954       {
21955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21956       };
21957     } catch (...) {
21958       {
21959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21960       };
21961     }
21962   }
21963
21964   jresult = SWIG_csharp_string_callback((&result)->c_str());
21965   return jresult;
21966 }
21967
21968
21969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21970   void * jresult ;
21971   std::type_info *arg1 = 0 ;
21972   std::type_info *arg2 = 0 ;
21973   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21974   Dali::TypeRegistration *result = 0 ;
21975
21976   arg1 = (std::type_info *)jarg1;
21977   if (!arg1) {
21978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21979     return 0;
21980   }
21981   arg2 = (std::type_info *)jarg2;
21982   if (!arg2) {
21983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21984     return 0;
21985   }
21986   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21987   {
21988     try {
21989       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21990     } catch (std::out_of_range& e) {
21991       {
21992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21993       };
21994     } catch (std::exception& e) {
21995       {
21996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21997       };
21998     } catch (Dali::DaliException e) {
21999       {
22000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22001       };
22002     } catch (...) {
22003       {
22004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22005       };
22006     }
22007   }
22008
22009   jresult = (void *)result;
22010   return jresult;
22011 }
22012
22013
22014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22015   void * jresult ;
22016   std::type_info *arg1 = 0 ;
22017   std::type_info *arg2 = 0 ;
22018   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22019   bool arg4 ;
22020   Dali::TypeRegistration *result = 0 ;
22021
22022   arg1 = (std::type_info *)jarg1;
22023   if (!arg1) {
22024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22025     return 0;
22026   }
22027   arg2 = (std::type_info *)jarg2;
22028   if (!arg2) {
22029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22030     return 0;
22031   }
22032   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22033   arg4 = jarg4 ? true : false;
22034   {
22035     try {
22036       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22037     } catch (std::out_of_range& e) {
22038       {
22039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22040       };
22041     } catch (std::exception& e) {
22042       {
22043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22044       };
22045     } catch (Dali::DaliException e) {
22046       {
22047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22048       };
22049     } catch (...) {
22050       {
22051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22052       };
22053     }
22054   }
22055
22056   jresult = (void *)result;
22057   return jresult;
22058 }
22059
22060
22061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22062   void * jresult ;
22063   std::string *arg1 = 0 ;
22064   std::type_info *arg2 = 0 ;
22065   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22066   Dali::TypeRegistration *result = 0 ;
22067
22068   if (!jarg1) {
22069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22070     return 0;
22071   }
22072   std::string arg1_str(jarg1);
22073   arg1 = &arg1_str;
22074   arg2 = (std::type_info *)jarg2;
22075   if (!arg2) {
22076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22077     return 0;
22078   }
22079   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22080   {
22081     try {
22082       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22083     } catch (std::out_of_range& e) {
22084       {
22085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22086       };
22087     } catch (std::exception& e) {
22088       {
22089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22090       };
22091     } catch (Dali::DaliException e) {
22092       {
22093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22094       };
22095     } catch (...) {
22096       {
22097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22098       };
22099     }
22100   }
22101
22102   jresult = (void *)result;
22103
22104   //argout typemap for const std::string&
22105
22106   return jresult;
22107 }
22108
22109
22110 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22111   char * jresult ;
22112   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22113   std::string result;
22114
22115   arg1 = (Dali::TypeRegistration *)jarg1;
22116   {
22117     try {
22118       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22119     } catch (std::out_of_range& e) {
22120       {
22121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22122       };
22123     } catch (std::exception& e) {
22124       {
22125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22126       };
22127     } catch (Dali::DaliException e) {
22128       {
22129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22130       };
22131     } catch (...) {
22132       {
22133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22134       };
22135     }
22136   }
22137
22138   jresult = SWIG_csharp_string_callback((&result)->c_str());
22139   return jresult;
22140 }
22141
22142
22143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22144   std::string *arg1 = 0 ;
22145   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22146
22147   if (!jarg1) {
22148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22149     return ;
22150   }
22151   std::string arg1_str(jarg1);
22152   arg1 = &arg1_str;
22153   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22154   {
22155     try {
22156       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22157     } catch (std::out_of_range& e) {
22158       {
22159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22160       };
22161     } catch (std::exception& e) {
22162       {
22163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22164       };
22165     } catch (Dali::DaliException e) {
22166       {
22167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22168       };
22169     } catch (...) {
22170       {
22171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22172       };
22173     }
22174   }
22175
22176
22177   //argout typemap for const std::string&
22178
22179 }
22180
22181
22182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22183   std::string *arg1 = 0 ;
22184   std::string *arg2 = 0 ;
22185   int arg3 ;
22186   Dali::Property::Type arg4 ;
22187   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22188   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22189
22190   if (!jarg1) {
22191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22192     return ;
22193   }
22194   std::string arg1_str(jarg1);
22195   arg1 = &arg1_str;
22196   if (!jarg2) {
22197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22198     return ;
22199   }
22200   std::string arg2_str(jarg2);
22201   arg2 = &arg2_str;
22202   arg3 = (int)jarg3;
22203   arg4 = (Dali::Property::Type)jarg4;
22204   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22205   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22206   {
22207     try {
22208       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22209     } catch (std::out_of_range& e) {
22210       {
22211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22212       };
22213     } catch (std::exception& e) {
22214       {
22215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22216       };
22217     } catch (Dali::DaliException e) {
22218       {
22219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22220       };
22221     } catch (...) {
22222       {
22223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22224       };
22225     }
22226   }
22227
22228
22229   //argout typemap for const std::string&
22230
22231
22232   //argout typemap for const std::string&
22233
22234 }
22235
22236
22237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22238   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22239
22240   arg1 = (Dali::TypeRegistration *)jarg1;
22241   {
22242     try {
22243       delete arg1;
22244     } catch (std::out_of_range& e) {
22245       {
22246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22247       };
22248     } catch (std::exception& e) {
22249       {
22250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22251       };
22252     } catch (Dali::DaliException e) {
22253       {
22254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22255       };
22256     } catch (...) {
22257       {
22258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22259       };
22260     }
22261   }
22262
22263 }
22264
22265
22266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22267   void * jresult ;
22268   Dali::TypeRegistration *arg1 = 0 ;
22269   std::string *arg2 = 0 ;
22270   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22271   Dali::SignalConnectorType *result = 0 ;
22272
22273   arg1 = (Dali::TypeRegistration *)jarg1;
22274   if (!arg1) {
22275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22276     return 0;
22277   }
22278   if (!jarg2) {
22279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22280     return 0;
22281   }
22282   std::string arg2_str(jarg2);
22283   arg2 = &arg2_str;
22284   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22285   {
22286     try {
22287       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22288     } catch (std::out_of_range& e) {
22289       {
22290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22291       };
22292     } catch (std::exception& e) {
22293       {
22294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22295       };
22296     } catch (Dali::DaliException e) {
22297       {
22298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22299       };
22300     } catch (...) {
22301       {
22302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22303       };
22304     }
22305   }
22306
22307   jresult = (void *)result;
22308
22309   //argout typemap for const std::string&
22310
22311   return jresult;
22312 }
22313
22314
22315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22316   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22317
22318   arg1 = (Dali::SignalConnectorType *)jarg1;
22319   {
22320     try {
22321       delete arg1;
22322     } catch (std::out_of_range& e) {
22323       {
22324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22325       };
22326     } catch (std::exception& e) {
22327       {
22328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22329       };
22330     } catch (Dali::DaliException e) {
22331       {
22332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22333       };
22334     } catch (...) {
22335       {
22336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22337       };
22338     }
22339   }
22340
22341 }
22342
22343
22344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22345   void * jresult ;
22346   Dali::TypeRegistration *arg1 = 0 ;
22347   std::string *arg2 = 0 ;
22348   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22349   Dali::TypeAction *result = 0 ;
22350
22351   arg1 = (Dali::TypeRegistration *)jarg1;
22352   if (!arg1) {
22353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22354     return 0;
22355   }
22356   if (!jarg2) {
22357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22358     return 0;
22359   }
22360   std::string arg2_str(jarg2);
22361   arg2 = &arg2_str;
22362   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22363   {
22364     try {
22365       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22366     } catch (std::out_of_range& e) {
22367       {
22368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22369       };
22370     } catch (std::exception& e) {
22371       {
22372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22373       };
22374     } catch (Dali::DaliException e) {
22375       {
22376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22377       };
22378     } catch (...) {
22379       {
22380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22381       };
22382     }
22383   }
22384
22385   jresult = (void *)result;
22386
22387   //argout typemap for const std::string&
22388
22389   return jresult;
22390 }
22391
22392
22393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22394   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22395
22396   arg1 = (Dali::TypeAction *)jarg1;
22397   {
22398     try {
22399       delete arg1;
22400     } catch (std::out_of_range& e) {
22401       {
22402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22403       };
22404     } catch (std::exception& e) {
22405       {
22406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22407       };
22408     } catch (Dali::DaliException e) {
22409       {
22410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22411       };
22412     } catch (...) {
22413       {
22414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22415       };
22416     }
22417   }
22418
22419 }
22420
22421
22422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22423   void * jresult ;
22424   Dali::TypeRegistration *arg1 = 0 ;
22425   std::string *arg2 = 0 ;
22426   Dali::Property::Index arg3 ;
22427   Dali::Property::Type arg4 ;
22428   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22429   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22430   Dali::PropertyRegistration *result = 0 ;
22431
22432   arg1 = (Dali::TypeRegistration *)jarg1;
22433   if (!arg1) {
22434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22435     return 0;
22436   }
22437   if (!jarg2) {
22438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22439     return 0;
22440   }
22441   std::string arg2_str(jarg2);
22442   arg2 = &arg2_str;
22443   arg3 = (Dali::Property::Index)jarg3;
22444   arg4 = (Dali::Property::Type)jarg4;
22445   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22446   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22447   {
22448     try {
22449       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22450     } catch (std::out_of_range& e) {
22451       {
22452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22453       };
22454     } catch (std::exception& e) {
22455       {
22456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22457       };
22458     } catch (Dali::DaliException e) {
22459       {
22460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22461       };
22462     } catch (...) {
22463       {
22464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22465       };
22466     }
22467   }
22468
22469   jresult = (void *)result;
22470
22471   //argout typemap for const std::string&
22472
22473   return jresult;
22474 }
22475
22476
22477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22478   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22479
22480   arg1 = (Dali::PropertyRegistration *)jarg1;
22481   {
22482     try {
22483       delete arg1;
22484     } catch (std::out_of_range& e) {
22485       {
22486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22487       };
22488     } catch (std::exception& e) {
22489       {
22490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22491       };
22492     } catch (Dali::DaliException e) {
22493       {
22494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22495       };
22496     } catch (...) {
22497       {
22498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22499       };
22500     }
22501   }
22502
22503 }
22504
22505
22506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22507   void * jresult ;
22508   Dali::TypeRegistration *arg1 = 0 ;
22509   std::string *arg2 = 0 ;
22510   Dali::Property::Index arg3 ;
22511   Dali::Property::Type arg4 ;
22512   Dali::AnimatablePropertyRegistration *result = 0 ;
22513
22514   arg1 = (Dali::TypeRegistration *)jarg1;
22515   if (!arg1) {
22516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22517     return 0;
22518   }
22519   if (!jarg2) {
22520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22521     return 0;
22522   }
22523   std::string arg2_str(jarg2);
22524   arg2 = &arg2_str;
22525   arg3 = (Dali::Property::Index)jarg3;
22526   arg4 = (Dali::Property::Type)jarg4;
22527   {
22528     try {
22529       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22530     } catch (std::out_of_range& e) {
22531       {
22532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22533       };
22534     } catch (std::exception& e) {
22535       {
22536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22537       };
22538     } catch (Dali::DaliException e) {
22539       {
22540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22541       };
22542     } catch (...) {
22543       {
22544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22545       };
22546     }
22547   }
22548
22549   jresult = (void *)result;
22550
22551   //argout typemap for const std::string&
22552
22553   return jresult;
22554 }
22555
22556
22557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22558   void * jresult ;
22559   Dali::TypeRegistration *arg1 = 0 ;
22560   std::string *arg2 = 0 ;
22561   Dali::Property::Index arg3 ;
22562   Dali::Property::Value *arg4 = 0 ;
22563   Dali::AnimatablePropertyRegistration *result = 0 ;
22564
22565   arg1 = (Dali::TypeRegistration *)jarg1;
22566   if (!arg1) {
22567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22568     return 0;
22569   }
22570   if (!jarg2) {
22571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22572     return 0;
22573   }
22574   std::string arg2_str(jarg2);
22575   arg2 = &arg2_str;
22576   arg3 = (Dali::Property::Index)jarg3;
22577   arg4 = (Dali::Property::Value *)jarg4;
22578   if (!arg4) {
22579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22580     return 0;
22581   }
22582   {
22583     try {
22584       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22585     } catch (std::out_of_range& e) {
22586       {
22587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22588       };
22589     } catch (std::exception& e) {
22590       {
22591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22592       };
22593     } catch (Dali::DaliException e) {
22594       {
22595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22596       };
22597     } catch (...) {
22598       {
22599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22600       };
22601     }
22602   }
22603
22604   jresult = (void *)result;
22605
22606   //argout typemap for const std::string&
22607
22608   return jresult;
22609 }
22610
22611
22612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22613   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22614
22615   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22616   {
22617     try {
22618       delete arg1;
22619     } catch (std::out_of_range& e) {
22620       {
22621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22622       };
22623     } catch (std::exception& e) {
22624       {
22625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22626       };
22627     } catch (Dali::DaliException e) {
22628       {
22629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22630       };
22631     } catch (...) {
22632       {
22633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22634       };
22635     }
22636   }
22637
22638 }
22639
22640
22641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22642   void * jresult ;
22643   Dali::TypeRegistration *arg1 = 0 ;
22644   std::string *arg2 = 0 ;
22645   Dali::Property::Index arg3 ;
22646   Dali::Property::Index arg4 ;
22647   unsigned int arg5 ;
22648   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22649
22650   arg1 = (Dali::TypeRegistration *)jarg1;
22651   if (!arg1) {
22652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22653     return 0;
22654   }
22655   if (!jarg2) {
22656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22657     return 0;
22658   }
22659   std::string arg2_str(jarg2);
22660   arg2 = &arg2_str;
22661   arg3 = (Dali::Property::Index)jarg3;
22662   arg4 = (Dali::Property::Index)jarg4;
22663   arg5 = (unsigned int)jarg5;
22664   {
22665     try {
22666       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22667     } catch (std::out_of_range& e) {
22668       {
22669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22670       };
22671     } catch (std::exception& e) {
22672       {
22673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22674       };
22675     } catch (Dali::DaliException e) {
22676       {
22677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22678       };
22679     } catch (...) {
22680       {
22681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22682       };
22683     }
22684   }
22685
22686   jresult = (void *)result;
22687
22688   //argout typemap for const std::string&
22689
22690   return jresult;
22691 }
22692
22693
22694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22695   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22696
22697   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22698   {
22699     try {
22700       delete arg1;
22701     } catch (std::out_of_range& e) {
22702       {
22703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22704       };
22705     } catch (std::exception& e) {
22706       {
22707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22708       };
22709     } catch (Dali::DaliException e) {
22710       {
22711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22712       };
22713     } catch (...) {
22714       {
22715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22716       };
22717     }
22718   }
22719
22720 }
22721
22722
22723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22724   void * jresult ;
22725   Dali::TypeRegistration *arg1 = 0 ;
22726   std::string *arg2 = 0 ;
22727   Dali::Property::Index arg3 ;
22728   Dali::Property::Type arg4 ;
22729   Dali::ChildPropertyRegistration *result = 0 ;
22730
22731   arg1 = (Dali::TypeRegistration *)jarg1;
22732   if (!arg1) {
22733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22734     return 0;
22735   }
22736   if (!jarg2) {
22737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22738     return 0;
22739   }
22740   std::string arg2_str(jarg2);
22741   arg2 = &arg2_str;
22742   arg3 = (Dali::Property::Index)jarg3;
22743   arg4 = (Dali::Property::Type)jarg4;
22744   {
22745     try {
22746       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22747     } catch (std::out_of_range& e) {
22748       {
22749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22750       };
22751     } catch (std::exception& e) {
22752       {
22753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22754       };
22755     } catch (Dali::DaliException e) {
22756       {
22757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22758       };
22759     } catch (...) {
22760       {
22761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22762       };
22763     }
22764   }
22765
22766   jresult = (void *)result;
22767
22768   //argout typemap for const std::string&
22769
22770   return jresult;
22771 }
22772
22773
22774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22775   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22776
22777   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22778   {
22779     try {
22780       delete arg1;
22781     } catch (std::out_of_range& e) {
22782       {
22783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22784       };
22785     } catch (std::exception& e) {
22786       {
22787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22788       };
22789     } catch (Dali::DaliException e) {
22790       {
22791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22792       };
22793     } catch (...) {
22794       {
22795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22796       };
22797     }
22798   }
22799
22800 }
22801
22802
22803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22804   unsigned int jresult ;
22805   std::string *arg1 = 0 ;
22806   std::type_info *arg2 = 0 ;
22807   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22808   bool result;
22809
22810   if (!jarg1) {
22811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22812     return 0;
22813   }
22814   std::string arg1_str(jarg1);
22815   arg1 = &arg1_str;
22816   arg2 = (std::type_info *)jarg2;
22817   if (!arg2) {
22818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22819     return 0;
22820   }
22821   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22822   {
22823     try {
22824       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22825     } catch (std::out_of_range& e) {
22826       {
22827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22828       };
22829     } catch (std::exception& e) {
22830       {
22831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22832       };
22833     } catch (Dali::DaliException e) {
22834       {
22835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22836       };
22837     } catch (...) {
22838       {
22839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22840       };
22841     }
22842   }
22843
22844   jresult = result;
22845
22846   //argout typemap for const std::string&
22847
22848   return jresult;
22849 }
22850
22851
22852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22853   unsigned int jresult ;
22854   std::string *arg1 = 0 ;
22855   std::string *arg2 = 0 ;
22856   Dali::Property::Index arg3 ;
22857   Dali::Property::Type arg4 ;
22858   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22859   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22860   bool result;
22861
22862   if (!jarg1) {
22863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22864     return 0;
22865   }
22866   std::string arg1_str(jarg1);
22867   arg1 = &arg1_str;
22868   if (!jarg2) {
22869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22870     return 0;
22871   }
22872   std::string arg2_str(jarg2);
22873   arg2 = &arg2_str;
22874   arg3 = (Dali::Property::Index)jarg3;
22875   arg4 = (Dali::Property::Type)jarg4;
22876   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22877   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22878   {
22879     try {
22880       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22881     } catch (std::out_of_range& e) {
22882       {
22883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22884       };
22885     } catch (std::exception& e) {
22886       {
22887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22888       };
22889     } catch (Dali::DaliException e) {
22890       {
22891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22892       };
22893     } catch (...) {
22894       {
22895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22896       };
22897     }
22898   }
22899
22900   jresult = result;
22901
22902   //argout typemap for const std::string&
22903
22904
22905   //argout typemap for const std::string&
22906
22907   return jresult;
22908 }
22909
22910
22911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22912   float jresult ;
22913   float result;
22914
22915   result = (float)(float)Dali::ParentOrigin::TOP;
22916   jresult = result;
22917   return jresult;
22918 }
22919
22920
22921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22922   float jresult ;
22923   float result;
22924
22925   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22926   jresult = result;
22927   return jresult;
22928 }
22929
22930
22931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22932   float jresult ;
22933   float result;
22934
22935   result = (float)(float)Dali::ParentOrigin::LEFT;
22936   jresult = result;
22937   return jresult;
22938 }
22939
22940
22941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22942   float jresult ;
22943   float result;
22944
22945   result = (float)(float)Dali::ParentOrigin::RIGHT;
22946   jresult = result;
22947   return jresult;
22948 }
22949
22950
22951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22952   float jresult ;
22953   float result;
22954
22955   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22956   jresult = result;
22957   return jresult;
22958 }
22959
22960
22961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22962   void * jresult ;
22963   Dali::Vector3 *result = 0 ;
22964
22965   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22966   jresult = (void *)result;
22967   return jresult;
22968 }
22969
22970
22971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22972   void * jresult ;
22973   Dali::Vector3 *result = 0 ;
22974
22975   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22976   jresult = (void *)result;
22977   return jresult;
22978 }
22979
22980
22981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22982   void * jresult ;
22983   Dali::Vector3 *result = 0 ;
22984
22985   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22986   jresult = (void *)result;
22987   return jresult;
22988 }
22989
22990
22991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22992   void * jresult ;
22993   Dali::Vector3 *result = 0 ;
22994
22995   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22996   jresult = (void *)result;
22997   return jresult;
22998 }
22999
23000
23001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23002   void * jresult ;
23003   Dali::Vector3 *result = 0 ;
23004
23005   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23006   jresult = (void *)result;
23007   return jresult;
23008 }
23009
23010
23011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23012   void * jresult ;
23013   Dali::Vector3 *result = 0 ;
23014
23015   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23016   jresult = (void *)result;
23017   return jresult;
23018 }
23019
23020
23021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23022   void * jresult ;
23023   Dali::Vector3 *result = 0 ;
23024
23025   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23026   jresult = (void *)result;
23027   return jresult;
23028 }
23029
23030
23031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23032   void * jresult ;
23033   Dali::Vector3 *result = 0 ;
23034
23035   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23036   jresult = (void *)result;
23037   return jresult;
23038 }
23039
23040
23041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23042   void * jresult ;
23043   Dali::Vector3 *result = 0 ;
23044
23045   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23046   jresult = (void *)result;
23047   return jresult;
23048 }
23049
23050
23051 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23052   float jresult ;
23053   float result;
23054
23055   result = (float)(float)Dali::AnchorPoint::TOP;
23056   jresult = result;
23057   return jresult;
23058 }
23059
23060
23061 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23062   float jresult ;
23063   float result;
23064
23065   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23066   jresult = result;
23067   return jresult;
23068 }
23069
23070
23071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23072   float jresult ;
23073   float result;
23074
23075   result = (float)(float)Dali::AnchorPoint::LEFT;
23076   jresult = result;
23077   return jresult;
23078 }
23079
23080
23081 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23082   float jresult ;
23083   float result;
23084
23085   result = (float)(float)Dali::AnchorPoint::RIGHT;
23086   jresult = result;
23087   return jresult;
23088 }
23089
23090
23091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23092   float jresult ;
23093   float result;
23094
23095   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23096   jresult = result;
23097   return jresult;
23098 }
23099
23100
23101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23102   void * jresult ;
23103   Dali::Vector3 *result = 0 ;
23104
23105   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23106   jresult = (void *)result;
23107   return jresult;
23108 }
23109
23110
23111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23112   void * jresult ;
23113   Dali::Vector3 *result = 0 ;
23114
23115   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23116   jresult = (void *)result;
23117   return jresult;
23118 }
23119
23120
23121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23122   void * jresult ;
23123   Dali::Vector3 *result = 0 ;
23124
23125   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23126   jresult = (void *)result;
23127   return jresult;
23128 }
23129
23130
23131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23132   void * jresult ;
23133   Dali::Vector3 *result = 0 ;
23134
23135   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23136   jresult = (void *)result;
23137   return jresult;
23138 }
23139
23140
23141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23142   void * jresult ;
23143   Dali::Vector3 *result = 0 ;
23144
23145   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23146   jresult = (void *)result;
23147   return jresult;
23148 }
23149
23150
23151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23152   void * jresult ;
23153   Dali::Vector3 *result = 0 ;
23154
23155   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23156   jresult = (void *)result;
23157   return jresult;
23158 }
23159
23160
23161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23162   void * jresult ;
23163   Dali::Vector3 *result = 0 ;
23164
23165   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23166   jresult = (void *)result;
23167   return jresult;
23168 }
23169
23170
23171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23172   void * jresult ;
23173   Dali::Vector3 *result = 0 ;
23174
23175   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23176   jresult = (void *)result;
23177   return jresult;
23178 }
23179
23180
23181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23182   void * jresult ;
23183   Dali::Vector3 *result = 0 ;
23184
23185   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23186   jresult = (void *)result;
23187   return jresult;
23188 }
23189
23190
23191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23192   void * jresult ;
23193   Dali::Vector4 *result = 0 ;
23194
23195   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23196   jresult = (void *)result;
23197   return jresult;
23198 }
23199
23200
23201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23202   void * jresult ;
23203   Dali::Vector4 *result = 0 ;
23204
23205   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23206   jresult = (void *)result;
23207   return jresult;
23208 }
23209
23210
23211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23212   void * jresult ;
23213   Dali::Vector4 *result = 0 ;
23214
23215   result = (Dali::Vector4 *)&Dali::Color::RED;
23216   jresult = (void *)result;
23217   return jresult;
23218 }
23219
23220
23221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23222   void * jresult ;
23223   Dali::Vector4 *result = 0 ;
23224
23225   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23226   jresult = (void *)result;
23227   return jresult;
23228 }
23229
23230
23231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23232   void * jresult ;
23233   Dali::Vector4 *result = 0 ;
23234
23235   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23236   jresult = (void *)result;
23237   return jresult;
23238 }
23239
23240
23241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23242   void * jresult ;
23243   Dali::Vector4 *result = 0 ;
23244
23245   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23246   jresult = (void *)result;
23247   return jresult;
23248 }
23249
23250
23251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23252   void * jresult ;
23253   Dali::Vector4 *result = 0 ;
23254
23255   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23256   jresult = (void *)result;
23257   return jresult;
23258 }
23259
23260
23261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23262   void * jresult ;
23263   Dali::Vector4 *result = 0 ;
23264
23265   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23266   jresult = (void *)result;
23267   return jresult;
23268 }
23269
23270
23271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23272   void * jresult ;
23273   Dali::Vector4 *result = 0 ;
23274
23275   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23276   jresult = (void *)result;
23277   return jresult;
23278 }
23279
23280
23281 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23282   float jresult ;
23283   float result;
23284
23285   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23286   jresult = result;
23287   return jresult;
23288 }
23289
23290
23291 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23292   float jresult ;
23293   float result;
23294
23295   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23296   jresult = result;
23297   return jresult;
23298 }
23299
23300
23301 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23302   float jresult ;
23303   float result;
23304
23305   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23306   jresult = result;
23307   return jresult;
23308 }
23309
23310
23311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23312   float jresult ;
23313   float result;
23314
23315   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23316   jresult = result;
23317   return jresult;
23318 }
23319
23320
23321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23322   float jresult ;
23323   float result;
23324
23325   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23326   jresult = result;
23327   return jresult;
23328 }
23329
23330
23331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23332   float jresult ;
23333   float result;
23334
23335   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23336   jresult = result;
23337   return jresult;
23338 }
23339
23340
23341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23342   float jresult ;
23343   float result;
23344
23345   result = (float)(float)Dali::Math::PI;
23346   jresult = result;
23347   return jresult;
23348 }
23349
23350
23351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23352   float jresult ;
23353   float result;
23354
23355   result = (float)(float)Dali::Math::PI_2;
23356   jresult = result;
23357   return jresult;
23358 }
23359
23360
23361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23362   float jresult ;
23363   float result;
23364
23365   result = (float)(float)Dali::Math::PI_4;
23366   jresult = result;
23367   return jresult;
23368 }
23369
23370
23371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23372   float jresult ;
23373   float result;
23374
23375   result = (float)(float)Dali::Math::PI_OVER_180;
23376   jresult = result;
23377   return jresult;
23378 }
23379
23380
23381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23382   float jresult ;
23383   float result;
23384
23385   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23386   jresult = result;
23387   return jresult;
23388 }
23389
23390
23391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23392   int jresult ;
23393   Dali::ResizePolicy::Type result;
23394
23395   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23396   jresult = (int)result;
23397   return jresult;
23398 }
23399
23400
23401 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23402   unsigned long jresult ;
23403   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23404   Dali::VectorBase::SizeType result;
23405
23406   arg1 = (Dali::VectorBase *)jarg1;
23407   {
23408     try {
23409       result = ((Dali::VectorBase const *)arg1)->Count();
23410     } catch (std::out_of_range& e) {
23411       {
23412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23413       };
23414     } catch (std::exception& e) {
23415       {
23416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23417       };
23418     } catch (Dali::DaliException e) {
23419       {
23420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23421       };
23422     } catch (...) {
23423       {
23424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23425       };
23426     }
23427   }
23428
23429   jresult = (unsigned long)result;
23430   return jresult;
23431 }
23432
23433
23434 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23435   unsigned long jresult ;
23436   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23437   Dali::VectorBase::SizeType result;
23438
23439   arg1 = (Dali::VectorBase *)jarg1;
23440   {
23441     try {
23442       result = ((Dali::VectorBase const *)arg1)->Size();
23443     } catch (std::out_of_range& e) {
23444       {
23445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23446       };
23447     } catch (std::exception& e) {
23448       {
23449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23450       };
23451     } catch (Dali::DaliException e) {
23452       {
23453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23454       };
23455     } catch (...) {
23456       {
23457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23458       };
23459     }
23460   }
23461
23462   jresult = (unsigned long)result;
23463   return jresult;
23464 }
23465
23466
23467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23468   unsigned int jresult ;
23469   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23470   bool result;
23471
23472   arg1 = (Dali::VectorBase *)jarg1;
23473   {
23474     try {
23475       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23476     } catch (std::out_of_range& e) {
23477       {
23478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23479       };
23480     } catch (std::exception& e) {
23481       {
23482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23483       };
23484     } catch (Dali::DaliException e) {
23485       {
23486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23487       };
23488     } catch (...) {
23489       {
23490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23491       };
23492     }
23493   }
23494
23495   jresult = result;
23496   return jresult;
23497 }
23498
23499
23500 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23501   unsigned long jresult ;
23502   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23503   Dali::VectorBase::SizeType result;
23504
23505   arg1 = (Dali::VectorBase *)jarg1;
23506   {
23507     try {
23508       result = ((Dali::VectorBase const *)arg1)->Capacity();
23509     } catch (std::out_of_range& e) {
23510       {
23511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23512       };
23513     } catch (std::exception& e) {
23514       {
23515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23516       };
23517     } catch (Dali::DaliException e) {
23518       {
23519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23520       };
23521     } catch (...) {
23522       {
23523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23524       };
23525     }
23526   }
23527
23528   jresult = (unsigned long)result;
23529   return jresult;
23530 }
23531
23532
23533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23534   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23535
23536   arg1 = (Dali::VectorBase *)jarg1;
23537   {
23538     try {
23539       (arg1)->Release();
23540     } catch (std::out_of_range& e) {
23541       {
23542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23543       };
23544     } catch (std::exception& e) {
23545       {
23546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23547       };
23548     } catch (Dali::DaliException e) {
23549       {
23550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23551       };
23552     } catch (...) {
23553       {
23554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23555       };
23556     }
23557   }
23558
23559 }
23560
23561
23562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23563   void * jresult ;
23564   Dali::Image *result = 0 ;
23565
23566   {
23567     try {
23568       result = (Dali::Image *)new Dali::Image();
23569     } catch (std::out_of_range& e) {
23570       {
23571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23572       };
23573     } catch (std::exception& e) {
23574       {
23575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23576       };
23577     } catch (Dali::DaliException e) {
23578       {
23579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23580       };
23581     } catch (...) {
23582       {
23583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23584       };
23585     }
23586   }
23587
23588   jresult = (void *)result;
23589   return jresult;
23590 }
23591
23592
23593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23594   Dali::Image *arg1 = (Dali::Image *) 0 ;
23595
23596   arg1 = (Dali::Image *)jarg1;
23597   {
23598     try {
23599       delete arg1;
23600     } catch (std::out_of_range& e) {
23601       {
23602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23603       };
23604     } catch (std::exception& e) {
23605       {
23606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23607       };
23608     } catch (Dali::DaliException e) {
23609       {
23610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23611       };
23612     } catch (...) {
23613       {
23614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23615       };
23616     }
23617   }
23618
23619 }
23620
23621
23622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23623   void * jresult ;
23624   Dali::Image *arg1 = 0 ;
23625   Dali::Image *result = 0 ;
23626
23627   arg1 = (Dali::Image *)jarg1;
23628   if (!arg1) {
23629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23630     return 0;
23631   }
23632   {
23633     try {
23634       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23635     } catch (std::out_of_range& e) {
23636       {
23637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23638       };
23639     } catch (std::exception& e) {
23640       {
23641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23642       };
23643     } catch (Dali::DaliException e) {
23644       {
23645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23646       };
23647     } catch (...) {
23648       {
23649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23650       };
23651     }
23652   }
23653
23654   jresult = (void *)result;
23655   return jresult;
23656 }
23657
23658
23659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23660   void * jresult ;
23661   Dali::Image *arg1 = (Dali::Image *) 0 ;
23662   Dali::Image *arg2 = 0 ;
23663   Dali::Image *result = 0 ;
23664
23665   arg1 = (Dali::Image *)jarg1;
23666   arg2 = (Dali::Image *)jarg2;
23667   if (!arg2) {
23668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23669     return 0;
23670   }
23671   {
23672     try {
23673       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23674     } catch (std::out_of_range& e) {
23675       {
23676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23677       };
23678     } catch (std::exception& e) {
23679       {
23680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23681       };
23682     } catch (Dali::DaliException e) {
23683       {
23684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23685       };
23686     } catch (...) {
23687       {
23688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23689       };
23690     }
23691   }
23692
23693   jresult = (void *)result;
23694   return jresult;
23695 }
23696
23697
23698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23699   void * jresult ;
23700   Dali::BaseHandle arg1 ;
23701   Dali::BaseHandle *argp1 ;
23702   Dali::Image result;
23703
23704   argp1 = (Dali::BaseHandle *)jarg1;
23705   if (!argp1) {
23706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23707     return 0;
23708   }
23709   arg1 = *argp1;
23710   {
23711     try {
23712       result = Dali::Image::DownCast(arg1);
23713     } catch (std::out_of_range& e) {
23714       {
23715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23716       };
23717     } catch (std::exception& e) {
23718       {
23719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23720       };
23721     } catch (Dali::DaliException e) {
23722       {
23723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23724       };
23725     } catch (...) {
23726       {
23727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23728       };
23729     }
23730   }
23731
23732   jresult = new Dali::Image((const Dali::Image &)result);
23733   return jresult;
23734 }
23735
23736
23737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23738   unsigned int jresult ;
23739   Dali::Image *arg1 = (Dali::Image *) 0 ;
23740   unsigned int result;
23741
23742   arg1 = (Dali::Image *)jarg1;
23743   {
23744     try {
23745       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23746     } catch (std::out_of_range& e) {
23747       {
23748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23749       };
23750     } catch (std::exception& e) {
23751       {
23752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23753       };
23754     } catch (Dali::DaliException e) {
23755       {
23756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23757       };
23758     } catch (...) {
23759       {
23760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23761       };
23762     }
23763   }
23764
23765   jresult = result;
23766   return jresult;
23767 }
23768
23769
23770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23771   unsigned int jresult ;
23772   Dali::Image *arg1 = (Dali::Image *) 0 ;
23773   unsigned int result;
23774
23775   arg1 = (Dali::Image *)jarg1;
23776   {
23777     try {
23778       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23779     } catch (std::out_of_range& e) {
23780       {
23781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23782       };
23783     } catch (std::exception& e) {
23784       {
23785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23786       };
23787     } catch (Dali::DaliException e) {
23788       {
23789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23790       };
23791     } catch (...) {
23792       {
23793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23794       };
23795     }
23796   }
23797
23798   jresult = result;
23799   return jresult;
23800 }
23801
23802
23803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23804   void * jresult ;
23805   Dali::Image *arg1 = (Dali::Image *) 0 ;
23806   Dali::Image::ImageSignalType *result = 0 ;
23807
23808   arg1 = (Dali::Image *)jarg1;
23809   {
23810     try {
23811       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23812     } catch (std::out_of_range& e) {
23813       {
23814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23815       };
23816     } catch (std::exception& e) {
23817       {
23818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23819       };
23820     } catch (Dali::DaliException e) {
23821       {
23822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23823       };
23824     } catch (...) {
23825       {
23826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23827       };
23828     }
23829   }
23830
23831   jresult = (void *)result;
23832   return jresult;
23833 }
23834
23835
23836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23837   int jresult ;
23838   Dali::Pixel::Format result;
23839
23840   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23841   jresult = (int)result;
23842   return jresult;
23843 }
23844
23845
23846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23847   int jresult ;
23848   Dali::Pixel::Format result;
23849
23850   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23851   jresult = (int)result;
23852   return jresult;
23853 }
23854
23855
23856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23857   unsigned int jresult ;
23858   Dali::Pixel::Format arg1 ;
23859   bool result;
23860
23861   arg1 = (Dali::Pixel::Format)jarg1;
23862   {
23863     try {
23864       result = (bool)Dali::Pixel::HasAlpha(arg1);
23865     } catch (std::out_of_range& e) {
23866       {
23867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23868       };
23869     } catch (std::exception& e) {
23870       {
23871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23872       };
23873     } catch (Dali::DaliException e) {
23874       {
23875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23876       };
23877     } catch (...) {
23878       {
23879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23880       };
23881     }
23882   }
23883
23884   jresult = result;
23885   return jresult;
23886 }
23887
23888
23889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23890   unsigned int jresult ;
23891   Dali::Pixel::Format arg1 ;
23892   unsigned int result;
23893
23894   arg1 = (Dali::Pixel::Format)jarg1;
23895   {
23896     try {
23897       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23898     } catch (std::out_of_range& e) {
23899       {
23900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23901       };
23902     } catch (std::exception& e) {
23903       {
23904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23905       };
23906     } catch (Dali::DaliException e) {
23907       {
23908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23909       };
23910     } catch (...) {
23911       {
23912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23913       };
23914     }
23915   }
23916
23917   jresult = result;
23918   return jresult;
23919 }
23920
23921
23922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23923   Dali::Pixel::Format arg1 ;
23924   int *arg2 = 0 ;
23925   int *arg3 = 0 ;
23926
23927   arg1 = (Dali::Pixel::Format)jarg1;
23928   arg2 = (int *)jarg2;
23929   if (!arg2) {
23930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23931     return ;
23932   }
23933   arg3 = (int *)jarg3;
23934   if (!arg3) {
23935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23936     return ;
23937   }
23938   {
23939     try {
23940       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23941     } catch (std::out_of_range& e) {
23942       {
23943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23944       };
23945     } catch (std::exception& e) {
23946       {
23947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23948       };
23949     } catch (Dali::DaliException e) {
23950       {
23951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23952       };
23953     } catch (...) {
23954       {
23955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23956       };
23957     }
23958   }
23959
23960 }
23961
23962
23963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23964   void * jresult ;
23965   unsigned char *arg1 = (unsigned char *) 0 ;
23966   unsigned int arg2 ;
23967   unsigned int arg3 ;
23968   unsigned int arg4 ;
23969   Dali::Pixel::Format arg5 ;
23970   Dali::PixelData::ReleaseFunction arg6 ;
23971   Dali::PixelData result;
23972
23973   arg1 = jarg1;
23974   arg2 = (unsigned int)jarg2;
23975   arg3 = (unsigned int)jarg3;
23976   arg4 = (unsigned int)jarg4;
23977   arg5 = (Dali::Pixel::Format)jarg5;
23978   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23979   {
23980     try {
23981       auto pixelBuffer = new unsigned char[jarg2];
23982       memcpy( pixelBuffer, arg1, arg2);
23983       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23984     } catch (std::out_of_range& e) {
23985       {
23986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23987       };
23988     } catch (std::exception& e) {
23989       {
23990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23991       };
23992     } catch (Dali::DaliException e) {
23993       {
23994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23995       };
23996     } catch (...) {
23997       {
23998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23999       };
24000     }
24001   }
24002
24003   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24004
24005
24006   return jresult;
24007 }
24008
24009
24010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24011   void * jresult ;
24012   Dali::PixelData *result = 0 ;
24013
24014   {
24015     try {
24016       result = (Dali::PixelData *)new Dali::PixelData();
24017     } catch (std::out_of_range& e) {
24018       {
24019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24020       };
24021     } catch (std::exception& e) {
24022       {
24023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24024       };
24025     } catch (Dali::DaliException e) {
24026       {
24027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24028       };
24029     } catch (...) {
24030       {
24031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24032       };
24033     }
24034   }
24035
24036   jresult = (void *)result;
24037   return jresult;
24038 }
24039
24040
24041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24042   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24043
24044   arg1 = (Dali::PixelData *)jarg1;
24045   {
24046     try {
24047       delete arg1;
24048     } catch (std::out_of_range& e) {
24049       {
24050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24051       };
24052     } catch (std::exception& e) {
24053       {
24054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24055       };
24056     } catch (Dali::DaliException e) {
24057       {
24058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24059       };
24060     } catch (...) {
24061       {
24062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24063       };
24064     }
24065   }
24066
24067 }
24068
24069
24070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24071   void * jresult ;
24072   Dali::PixelData *arg1 = 0 ;
24073   Dali::PixelData *result = 0 ;
24074
24075   arg1 = (Dali::PixelData *)jarg1;
24076   if (!arg1) {
24077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24078     return 0;
24079   }
24080   {
24081     try {
24082       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24083     } catch (std::out_of_range& e) {
24084       {
24085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24086       };
24087     } catch (std::exception& e) {
24088       {
24089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24090       };
24091     } catch (Dali::DaliException e) {
24092       {
24093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24094       };
24095     } catch (...) {
24096       {
24097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24098       };
24099     }
24100   }
24101
24102   jresult = (void *)result;
24103   return jresult;
24104 }
24105
24106
24107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24108   void * jresult ;
24109   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24110   Dali::PixelData *arg2 = 0 ;
24111   Dali::PixelData *result = 0 ;
24112
24113   arg1 = (Dali::PixelData *)jarg1;
24114   arg2 = (Dali::PixelData *)jarg2;
24115   if (!arg2) {
24116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24117     return 0;
24118   }
24119   {
24120     try {
24121       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24122     } catch (std::out_of_range& e) {
24123       {
24124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24125       };
24126     } catch (std::exception& e) {
24127       {
24128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24129       };
24130     } catch (Dali::DaliException e) {
24131       {
24132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24133       };
24134     } catch (...) {
24135       {
24136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24137       };
24138     }
24139   }
24140
24141   jresult = (void *)result;
24142   return jresult;
24143 }
24144
24145
24146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24147   unsigned int jresult ;
24148   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24149   unsigned int result;
24150
24151   arg1 = (Dali::PixelData *)jarg1;
24152   {
24153     try {
24154       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24155     } catch (std::out_of_range& e) {
24156       {
24157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24158       };
24159     } catch (std::exception& e) {
24160       {
24161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24162       };
24163     } catch (Dali::DaliException e) {
24164       {
24165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24166       };
24167     } catch (...) {
24168       {
24169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24170       };
24171     }
24172   }
24173
24174   jresult = result;
24175   return jresult;
24176 }
24177
24178
24179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24180   unsigned int jresult ;
24181   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24182   unsigned int result;
24183
24184   arg1 = (Dali::PixelData *)jarg1;
24185   {
24186     try {
24187       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24188     } catch (std::out_of_range& e) {
24189       {
24190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24191       };
24192     } catch (std::exception& e) {
24193       {
24194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24195       };
24196     } catch (Dali::DaliException e) {
24197       {
24198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24199       };
24200     } catch (...) {
24201       {
24202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24203       };
24204     }
24205   }
24206
24207   jresult = result;
24208   return jresult;
24209 }
24210
24211
24212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24213   int jresult ;
24214   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24215   Dali::Pixel::Format result;
24216
24217   arg1 = (Dali::PixelData *)jarg1;
24218   {
24219     try {
24220       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24221     } catch (std::out_of_range& e) {
24222       {
24223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24224       };
24225     } catch (std::exception& e) {
24226       {
24227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24228       };
24229     } catch (Dali::DaliException e) {
24230       {
24231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24232       };
24233     } catch (...) {
24234       {
24235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24236       };
24237     }
24238   }
24239
24240   jresult = (int)result;
24241   return jresult;
24242 }
24243
24244
24245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24246   unsigned int jresult ;
24247   unsigned int result;
24248
24249   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24250   jresult = result;
24251   return jresult;
24252 }
24253
24254
24255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24256   unsigned int jresult ;
24257   unsigned int result;
24258
24259   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24260   jresult = result;
24261   return jresult;
24262 }
24263
24264
24265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24266   unsigned int jresult ;
24267   unsigned int result;
24268
24269   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24270   jresult = result;
24271   return jresult;
24272 }
24273
24274
24275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24276   unsigned int jresult ;
24277   unsigned int result;
24278
24279   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24280   jresult = result;
24281   return jresult;
24282 }
24283
24284
24285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24286   unsigned int jresult ;
24287   unsigned int result;
24288
24289   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24290   jresult = result;
24291   return jresult;
24292 }
24293
24294
24295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24296   unsigned int jresult ;
24297   unsigned int result;
24298
24299   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24300   jresult = result;
24301   return jresult;
24302 }
24303
24304
24305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24306   void * jresult ;
24307   Dali::TextureType::Type arg1 ;
24308   Dali::Pixel::Format arg2 ;
24309   unsigned int arg3 ;
24310   unsigned int arg4 ;
24311   Dali::Texture result;
24312
24313   arg1 = (Dali::TextureType::Type)jarg1;
24314   arg2 = (Dali::Pixel::Format)jarg2;
24315   arg3 = (unsigned int)jarg3;
24316   arg4 = (unsigned int)jarg4;
24317   {
24318     try {
24319       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24320     } catch (std::out_of_range& e) {
24321       {
24322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24323       };
24324     } catch (std::exception& e) {
24325       {
24326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24327       };
24328     } catch (Dali::DaliException e) {
24329       {
24330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24331       };
24332     } catch (...) {
24333       {
24334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24335       };
24336     }
24337   }
24338
24339   jresult = new Dali::Texture((const Dali::Texture &)result);
24340   return jresult;
24341 }
24342
24343
24344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24345   void * jresult ;
24346   NativeImageInterface *arg1 = 0 ;
24347   Dali::Texture result;
24348
24349   arg1 = (NativeImageInterface *)jarg1;
24350   if (!arg1) {
24351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24352     return 0;
24353   }
24354   {
24355     try {
24356       result = Dali::Texture::New(*arg1);
24357     } catch (std::out_of_range& e) {
24358       {
24359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24360       };
24361     } catch (std::exception& e) {
24362       {
24363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24364       };
24365     } catch (Dali::DaliException e) {
24366       {
24367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24368       };
24369     } catch (...) {
24370       {
24371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24372       };
24373     }
24374   }
24375
24376   jresult = new Dali::Texture((const Dali::Texture &)result);
24377   return jresult;
24378 }
24379
24380
24381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24382   void * jresult ;
24383   Dali::Texture *result = 0 ;
24384
24385   {
24386     try {
24387       result = (Dali::Texture *)new Dali::Texture();
24388     } catch (std::out_of_range& e) {
24389       {
24390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24391       };
24392     } catch (std::exception& e) {
24393       {
24394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24395       };
24396     } catch (Dali::DaliException e) {
24397       {
24398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24399       };
24400     } catch (...) {
24401       {
24402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24403       };
24404     }
24405   }
24406
24407   jresult = (void *)result;
24408   return jresult;
24409 }
24410
24411
24412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24413   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24414
24415   arg1 = (Dali::Texture *)jarg1;
24416   {
24417     try {
24418       delete arg1;
24419     } catch (std::out_of_range& e) {
24420       {
24421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24422       };
24423     } catch (std::exception& e) {
24424       {
24425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24426       };
24427     } catch (Dali::DaliException e) {
24428       {
24429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24430       };
24431     } catch (...) {
24432       {
24433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24434       };
24435     }
24436   }
24437
24438 }
24439
24440
24441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24442   void * jresult ;
24443   Dali::Texture *arg1 = 0 ;
24444   Dali::Texture *result = 0 ;
24445
24446   arg1 = (Dali::Texture *)jarg1;
24447   if (!arg1) {
24448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24449     return 0;
24450   }
24451   {
24452     try {
24453       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24454     } catch (std::out_of_range& e) {
24455       {
24456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24457       };
24458     } catch (std::exception& e) {
24459       {
24460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24461       };
24462     } catch (Dali::DaliException e) {
24463       {
24464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24465       };
24466     } catch (...) {
24467       {
24468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24469       };
24470     }
24471   }
24472
24473   jresult = (void *)result;
24474   return jresult;
24475 }
24476
24477
24478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24479   void * jresult ;
24480   Dali::BaseHandle arg1 ;
24481   Dali::BaseHandle *argp1 ;
24482   Dali::Texture result;
24483
24484   argp1 = (Dali::BaseHandle *)jarg1;
24485   if (!argp1) {
24486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24487     return 0;
24488   }
24489   arg1 = *argp1;
24490   {
24491     try {
24492       result = Dali::Texture::DownCast(arg1);
24493     } catch (std::out_of_range& e) {
24494       {
24495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24496       };
24497     } catch (std::exception& e) {
24498       {
24499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24500       };
24501     } catch (Dali::DaliException e) {
24502       {
24503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24504       };
24505     } catch (...) {
24506       {
24507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24508       };
24509     }
24510   }
24511
24512   jresult = new Dali::Texture((const Dali::Texture &)result);
24513   return jresult;
24514 }
24515
24516
24517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24518   void * jresult ;
24519   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24520   Dali::Texture *arg2 = 0 ;
24521   Dali::Texture *result = 0 ;
24522
24523   arg1 = (Dali::Texture *)jarg1;
24524   arg2 = (Dali::Texture *)jarg2;
24525   if (!arg2) {
24526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24527     return 0;
24528   }
24529   {
24530     try {
24531       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24532     } catch (std::out_of_range& e) {
24533       {
24534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24535       };
24536     } catch (std::exception& e) {
24537       {
24538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24539       };
24540     } catch (Dali::DaliException e) {
24541       {
24542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24543       };
24544     } catch (...) {
24545       {
24546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24547       };
24548     }
24549   }
24550
24551   jresult = (void *)result;
24552   return jresult;
24553 }
24554
24555
24556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24557   unsigned int jresult ;
24558   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24559   Dali::PixelData arg2 ;
24560   Dali::PixelData *argp2 ;
24561   bool result;
24562
24563   arg1 = (Dali::Texture *)jarg1;
24564   argp2 = (Dali::PixelData *)jarg2;
24565   if (!argp2) {
24566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24567     return 0;
24568   }
24569   arg2 = *argp2;
24570   {
24571     try {
24572       result = (bool)(arg1)->Upload(arg2);
24573     } catch (std::out_of_range& e) {
24574       {
24575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24576       };
24577     } catch (std::exception& e) {
24578       {
24579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24580       };
24581     } catch (Dali::DaliException e) {
24582       {
24583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24584       };
24585     } catch (...) {
24586       {
24587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24588       };
24589     }
24590   }
24591
24592   jresult = result;
24593   return jresult;
24594 }
24595
24596
24597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) {
24598   unsigned int jresult ;
24599   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24600   Dali::PixelData arg2 ;
24601   unsigned int arg3 ;
24602   unsigned int arg4 ;
24603   unsigned int arg5 ;
24604   unsigned int arg6 ;
24605   unsigned int arg7 ;
24606   unsigned int arg8 ;
24607   Dali::PixelData *argp2 ;
24608   bool result;
24609
24610   arg1 = (Dali::Texture *)jarg1;
24611   argp2 = (Dali::PixelData *)jarg2;
24612   if (!argp2) {
24613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24614     return 0;
24615   }
24616   arg2 = *argp2;
24617   arg3 = (unsigned int)jarg3;
24618   arg4 = (unsigned int)jarg4;
24619   arg5 = (unsigned int)jarg5;
24620   arg6 = (unsigned int)jarg6;
24621   arg7 = (unsigned int)jarg7;
24622   arg8 = (unsigned int)jarg8;
24623   {
24624     try {
24625       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24626     } catch (std::out_of_range& e) {
24627       {
24628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24629       };
24630     } catch (std::exception& e) {
24631       {
24632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24633       };
24634     } catch (Dali::DaliException e) {
24635       {
24636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24637       };
24638     } catch (...) {
24639       {
24640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24641       };
24642     }
24643   }
24644
24645   jresult = result;
24646   return jresult;
24647 }
24648
24649
24650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24651   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24652
24653   arg1 = (Dali::Texture *)jarg1;
24654   {
24655     try {
24656       (arg1)->GenerateMipmaps();
24657     } catch (std::out_of_range& e) {
24658       {
24659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24660       };
24661     } catch (std::exception& e) {
24662       {
24663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24664       };
24665     } catch (Dali::DaliException e) {
24666       {
24667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24668       };
24669     } catch (...) {
24670       {
24671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24672       };
24673     }
24674   }
24675
24676 }
24677
24678
24679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24680   unsigned int jresult ;
24681   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24682   unsigned int result;
24683
24684   arg1 = (Dali::Texture *)jarg1;
24685   {
24686     try {
24687       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24688     } catch (std::out_of_range& e) {
24689       {
24690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24691       };
24692     } catch (std::exception& e) {
24693       {
24694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24695       };
24696     } catch (Dali::DaliException e) {
24697       {
24698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24699       };
24700     } catch (...) {
24701       {
24702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24703       };
24704     }
24705   }
24706
24707   jresult = result;
24708   return jresult;
24709 }
24710
24711
24712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24713   unsigned int jresult ;
24714   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24715   unsigned int result;
24716
24717   arg1 = (Dali::Texture *)jarg1;
24718   {
24719     try {
24720       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24721     } catch (std::out_of_range& e) {
24722       {
24723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24724       };
24725     } catch (std::exception& e) {
24726       {
24727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24728       };
24729     } catch (Dali::DaliException e) {
24730       {
24731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24732       };
24733     } catch (...) {
24734       {
24735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24736       };
24737     }
24738   }
24739
24740   jresult = result;
24741   return jresult;
24742 }
24743
24744
24745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24746   void * jresult ;
24747   Dali::Sampler result;
24748
24749   {
24750     try {
24751       result = Dali::Sampler::New();
24752     } catch (std::out_of_range& e) {
24753       {
24754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24755       };
24756     } catch (std::exception& e) {
24757       {
24758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24759       };
24760     } catch (Dali::DaliException e) {
24761       {
24762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24763       };
24764     } catch (...) {
24765       {
24766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24767       };
24768     }
24769   }
24770
24771   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24772   return jresult;
24773 }
24774
24775
24776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24777   void * jresult ;
24778   Dali::Sampler *result = 0 ;
24779
24780   {
24781     try {
24782       result = (Dali::Sampler *)new Dali::Sampler();
24783     } catch (std::out_of_range& e) {
24784       {
24785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24786       };
24787     } catch (std::exception& e) {
24788       {
24789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24790       };
24791     } catch (Dali::DaliException e) {
24792       {
24793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24794       };
24795     } catch (...) {
24796       {
24797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24798       };
24799     }
24800   }
24801
24802   jresult = (void *)result;
24803   return jresult;
24804 }
24805
24806
24807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24808   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24809
24810   arg1 = (Dali::Sampler *)jarg1;
24811   {
24812     try {
24813       delete arg1;
24814     } catch (std::out_of_range& e) {
24815       {
24816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24817       };
24818     } catch (std::exception& e) {
24819       {
24820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24821       };
24822     } catch (Dali::DaliException e) {
24823       {
24824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24825       };
24826     } catch (...) {
24827       {
24828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24829       };
24830     }
24831   }
24832
24833 }
24834
24835
24836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24837   void * jresult ;
24838   Dali::Sampler *arg1 = 0 ;
24839   Dali::Sampler *result = 0 ;
24840
24841   arg1 = (Dali::Sampler *)jarg1;
24842   if (!arg1) {
24843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24844     return 0;
24845   }
24846   {
24847     try {
24848       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24849     } catch (std::out_of_range& e) {
24850       {
24851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24852       };
24853     } catch (std::exception& e) {
24854       {
24855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24856       };
24857     } catch (Dali::DaliException e) {
24858       {
24859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24860       };
24861     } catch (...) {
24862       {
24863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24864       };
24865     }
24866   }
24867
24868   jresult = (void *)result;
24869   return jresult;
24870 }
24871
24872
24873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24874   void * jresult ;
24875   Dali::BaseHandle arg1 ;
24876   Dali::BaseHandle *argp1 ;
24877   Dali::Sampler result;
24878
24879   argp1 = (Dali::BaseHandle *)jarg1;
24880   if (!argp1) {
24881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24882     return 0;
24883   }
24884   arg1 = *argp1;
24885   {
24886     try {
24887       result = Dali::Sampler::DownCast(arg1);
24888     } catch (std::out_of_range& e) {
24889       {
24890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24891       };
24892     } catch (std::exception& e) {
24893       {
24894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24895       };
24896     } catch (Dali::DaliException e) {
24897       {
24898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24899       };
24900     } catch (...) {
24901       {
24902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24903       };
24904     }
24905   }
24906
24907   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24908   return jresult;
24909 }
24910
24911
24912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24913   void * jresult ;
24914   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24915   Dali::Sampler *arg2 = 0 ;
24916   Dali::Sampler *result = 0 ;
24917
24918   arg1 = (Dali::Sampler *)jarg1;
24919   arg2 = (Dali::Sampler *)jarg2;
24920   if (!arg2) {
24921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24922     return 0;
24923   }
24924   {
24925     try {
24926       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24927     } catch (std::out_of_range& e) {
24928       {
24929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24930       };
24931     } catch (std::exception& e) {
24932       {
24933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24934       };
24935     } catch (Dali::DaliException e) {
24936       {
24937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24938       };
24939     } catch (...) {
24940       {
24941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24942       };
24943     }
24944   }
24945
24946   jresult = (void *)result;
24947   return jresult;
24948 }
24949
24950
24951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24952   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24953   Dali::FilterMode::Type arg2 ;
24954   Dali::FilterMode::Type arg3 ;
24955
24956   arg1 = (Dali::Sampler *)jarg1;
24957   arg2 = (Dali::FilterMode::Type)jarg2;
24958   arg3 = (Dali::FilterMode::Type)jarg3;
24959   {
24960     try {
24961       (arg1)->SetFilterMode(arg2,arg3);
24962     } catch (std::out_of_range& e) {
24963       {
24964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24965       };
24966     } catch (std::exception& e) {
24967       {
24968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24969       };
24970     } catch (Dali::DaliException e) {
24971       {
24972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24973       };
24974     } catch (...) {
24975       {
24976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24977       };
24978     }
24979   }
24980
24981 }
24982
24983
24984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24985   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24986   Dali::WrapMode::Type arg2 ;
24987   Dali::WrapMode::Type arg3 ;
24988
24989   arg1 = (Dali::Sampler *)jarg1;
24990   arg2 = (Dali::WrapMode::Type)jarg2;
24991   arg3 = (Dali::WrapMode::Type)jarg3;
24992   {
24993     try {
24994       (arg1)->SetWrapMode(arg2,arg3);
24995     } catch (std::out_of_range& e) {
24996       {
24997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24998       };
24999     } catch (std::exception& e) {
25000       {
25001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25002       };
25003     } catch (Dali::DaliException e) {
25004       {
25005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25006       };
25007     } catch (...) {
25008       {
25009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25010       };
25011     }
25012   }
25013
25014 }
25015
25016
25017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25018   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25019   Dali::WrapMode::Type arg2 ;
25020   Dali::WrapMode::Type arg3 ;
25021   Dali::WrapMode::Type arg4 ;
25022
25023   arg1 = (Dali::Sampler *)jarg1;
25024   arg2 = (Dali::WrapMode::Type)jarg2;
25025   arg3 = (Dali::WrapMode::Type)jarg3;
25026   arg4 = (Dali::WrapMode::Type)jarg4;
25027   {
25028     try {
25029       (arg1)->SetWrapMode(arg2,arg3,arg4);
25030     } catch (std::out_of_range& e) {
25031       {
25032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25033       };
25034     } catch (std::exception& e) {
25035       {
25036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25037       };
25038     } catch (Dali::DaliException e) {
25039       {
25040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25041       };
25042     } catch (...) {
25043       {
25044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25045       };
25046     }
25047   }
25048
25049 }
25050
25051
25052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25053   void * jresult ;
25054   Dali::TextureSet result;
25055
25056   {
25057     try {
25058       result = Dali::TextureSet::New();
25059     } catch (std::out_of_range& e) {
25060       {
25061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25062       };
25063     } catch (std::exception& e) {
25064       {
25065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25066       };
25067     } catch (Dali::DaliException e) {
25068       {
25069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25070       };
25071     } catch (...) {
25072       {
25073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25074       };
25075     }
25076   }
25077
25078   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25079   return jresult;
25080 }
25081
25082
25083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25084   void * jresult ;
25085   Dali::TextureSet *result = 0 ;
25086
25087   {
25088     try {
25089       result = (Dali::TextureSet *)new Dali::TextureSet();
25090     } catch (std::out_of_range& e) {
25091       {
25092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25093       };
25094     } catch (std::exception& e) {
25095       {
25096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25097       };
25098     } catch (Dali::DaliException e) {
25099       {
25100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25101       };
25102     } catch (...) {
25103       {
25104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25105       };
25106     }
25107   }
25108
25109   jresult = (void *)result;
25110   return jresult;
25111 }
25112
25113
25114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25115   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25116
25117   arg1 = (Dali::TextureSet *)jarg1;
25118   {
25119     try {
25120       delete arg1;
25121     } catch (std::out_of_range& e) {
25122       {
25123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25124       };
25125     } catch (std::exception& e) {
25126       {
25127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25128       };
25129     } catch (Dali::DaliException e) {
25130       {
25131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25132       };
25133     } catch (...) {
25134       {
25135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25136       };
25137     }
25138   }
25139
25140 }
25141
25142
25143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25144   void * jresult ;
25145   Dali::TextureSet *arg1 = 0 ;
25146   Dali::TextureSet *result = 0 ;
25147
25148   arg1 = (Dali::TextureSet *)jarg1;
25149   if (!arg1) {
25150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25151     return 0;
25152   }
25153   {
25154     try {
25155       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25156     } catch (std::out_of_range& e) {
25157       {
25158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25159       };
25160     } catch (std::exception& e) {
25161       {
25162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25163       };
25164     } catch (Dali::DaliException e) {
25165       {
25166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25167       };
25168     } catch (...) {
25169       {
25170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25171       };
25172     }
25173   }
25174
25175   jresult = (void *)result;
25176   return jresult;
25177 }
25178
25179
25180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25181   void * jresult ;
25182   Dali::BaseHandle arg1 ;
25183   Dali::BaseHandle *argp1 ;
25184   Dali::TextureSet result;
25185
25186   argp1 = (Dali::BaseHandle *)jarg1;
25187   if (!argp1) {
25188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25189     return 0;
25190   }
25191   arg1 = *argp1;
25192   {
25193     try {
25194       result = Dali::TextureSet::DownCast(arg1);
25195     } catch (std::out_of_range& e) {
25196       {
25197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25198       };
25199     } catch (std::exception& e) {
25200       {
25201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25202       };
25203     } catch (Dali::DaliException e) {
25204       {
25205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25206       };
25207     } catch (...) {
25208       {
25209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25210       };
25211     }
25212   }
25213
25214   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25215   return jresult;
25216 }
25217
25218
25219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25220   void * jresult ;
25221   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25222   Dali::TextureSet *arg2 = 0 ;
25223   Dali::TextureSet *result = 0 ;
25224
25225   arg1 = (Dali::TextureSet *)jarg1;
25226   arg2 = (Dali::TextureSet *)jarg2;
25227   if (!arg2) {
25228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25229     return 0;
25230   }
25231   {
25232     try {
25233       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25234     } catch (std::out_of_range& e) {
25235       {
25236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25237       };
25238     } catch (std::exception& e) {
25239       {
25240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25241       };
25242     } catch (Dali::DaliException e) {
25243       {
25244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25245       };
25246     } catch (...) {
25247       {
25248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25249       };
25250     }
25251   }
25252
25253   jresult = (void *)result;
25254   return jresult;
25255 }
25256
25257
25258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25259   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25260   size_t arg2 ;
25261   Dali::Texture arg3 ;
25262   Dali::Texture *argp3 ;
25263
25264   arg1 = (Dali::TextureSet *)jarg1;
25265   arg2 = (size_t)jarg2;
25266   argp3 = (Dali::Texture *)jarg3;
25267   if (!argp3) {
25268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25269     return ;
25270   }
25271   arg3 = *argp3;
25272   {
25273     try {
25274       (arg1)->SetTexture(arg2,arg3);
25275     } catch (std::out_of_range& e) {
25276       {
25277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25278       };
25279     } catch (std::exception& e) {
25280       {
25281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25282       };
25283     } catch (Dali::DaliException e) {
25284       {
25285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25286       };
25287     } catch (...) {
25288       {
25289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25290       };
25291     }
25292   }
25293
25294 }
25295
25296
25297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25298   void * jresult ;
25299   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25300   size_t arg2 ;
25301   Dali::Texture result;
25302
25303   arg1 = (Dali::TextureSet *)jarg1;
25304   arg2 = (size_t)jarg2;
25305   {
25306     try {
25307       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25308     } catch (std::out_of_range& e) {
25309       {
25310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25311       };
25312     } catch (std::exception& e) {
25313       {
25314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25315       };
25316     } catch (Dali::DaliException e) {
25317       {
25318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25319       };
25320     } catch (...) {
25321       {
25322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25323       };
25324     }
25325   }
25326
25327   jresult = new Dali::Texture((const Dali::Texture &)result);
25328   return jresult;
25329 }
25330
25331
25332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25333   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25334   size_t arg2 ;
25335   Dali::Sampler arg3 ;
25336   Dali::Sampler *argp3 ;
25337
25338   arg1 = (Dali::TextureSet *)jarg1;
25339   arg2 = (size_t)jarg2;
25340   argp3 = (Dali::Sampler *)jarg3;
25341   if (!argp3) {
25342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25343     return ;
25344   }
25345   arg3 = *argp3;
25346   {
25347     try {
25348       (arg1)->SetSampler(arg2,arg3);
25349     } catch (std::out_of_range& e) {
25350       {
25351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25352       };
25353     } catch (std::exception& e) {
25354       {
25355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25356       };
25357     } catch (Dali::DaliException e) {
25358       {
25359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25360       };
25361     } catch (...) {
25362       {
25363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25364       };
25365     }
25366   }
25367
25368 }
25369
25370
25371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25372   void * jresult ;
25373   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25374   size_t arg2 ;
25375   Dali::Sampler result;
25376
25377   arg1 = (Dali::TextureSet *)jarg1;
25378   arg2 = (size_t)jarg2;
25379   {
25380     try {
25381       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25382     } catch (std::out_of_range& e) {
25383       {
25384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25385       };
25386     } catch (std::exception& e) {
25387       {
25388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25389       };
25390     } catch (Dali::DaliException e) {
25391       {
25392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25393       };
25394     } catch (...) {
25395       {
25396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25397       };
25398     }
25399   }
25400
25401   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25402   return jresult;
25403 }
25404
25405
25406 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25407   unsigned long jresult ;
25408   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25409   size_t result;
25410
25411   arg1 = (Dali::TextureSet *)jarg1;
25412   {
25413     try {
25414       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25415     } catch (std::out_of_range& e) {
25416       {
25417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25418       };
25419     } catch (std::exception& e) {
25420       {
25421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25422       };
25423     } catch (Dali::DaliException e) {
25424       {
25425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25426       };
25427     } catch (...) {
25428       {
25429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25430       };
25431     }
25432   }
25433
25434   jresult = (unsigned long)result;
25435   return jresult;
25436 }
25437
25438
25439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25440   void * jresult ;
25441   Dali::Property::Map *arg1 = 0 ;
25442   Dali::PropertyBuffer result;
25443
25444   arg1 = (Dali::Property::Map *)jarg1;
25445   if (!arg1) {
25446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25447     return 0;
25448   }
25449   {
25450     try {
25451       result = Dali::PropertyBuffer::New(*arg1);
25452     } catch (std::out_of_range& e) {
25453       {
25454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25455       };
25456     } catch (std::exception& e) {
25457       {
25458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25459       };
25460     } catch (Dali::DaliException e) {
25461       {
25462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25463       };
25464     } catch (...) {
25465       {
25466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25467       };
25468     }
25469   }
25470
25471   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25472   return jresult;
25473 }
25474
25475
25476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25477   void * jresult ;
25478   Dali::PropertyBuffer *result = 0 ;
25479
25480   {
25481     try {
25482       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25483     } catch (std::out_of_range& e) {
25484       {
25485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25486       };
25487     } catch (std::exception& e) {
25488       {
25489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25490       };
25491     } catch (Dali::DaliException e) {
25492       {
25493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25494       };
25495     } catch (...) {
25496       {
25497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25498       };
25499     }
25500   }
25501
25502   jresult = (void *)result;
25503   return jresult;
25504 }
25505
25506
25507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25508   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25509
25510   arg1 = (Dali::PropertyBuffer *)jarg1;
25511   {
25512     try {
25513       delete arg1;
25514     } catch (std::out_of_range& e) {
25515       {
25516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25517       };
25518     } catch (std::exception& e) {
25519       {
25520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25521       };
25522     } catch (Dali::DaliException e) {
25523       {
25524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25525       };
25526     } catch (...) {
25527       {
25528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25529       };
25530     }
25531   }
25532
25533 }
25534
25535
25536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25537   void * jresult ;
25538   Dali::PropertyBuffer *arg1 = 0 ;
25539   Dali::PropertyBuffer *result = 0 ;
25540
25541   arg1 = (Dali::PropertyBuffer *)jarg1;
25542   if (!arg1) {
25543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25544     return 0;
25545   }
25546   {
25547     try {
25548       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25549     } catch (std::out_of_range& e) {
25550       {
25551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25552       };
25553     } catch (std::exception& e) {
25554       {
25555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25556       };
25557     } catch (Dali::DaliException e) {
25558       {
25559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25560       };
25561     } catch (...) {
25562       {
25563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25564       };
25565     }
25566   }
25567
25568   jresult = (void *)result;
25569   return jresult;
25570 }
25571
25572
25573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25574   void * jresult ;
25575   Dali::BaseHandle arg1 ;
25576   Dali::BaseHandle *argp1 ;
25577   Dali::PropertyBuffer result;
25578
25579   argp1 = (Dali::BaseHandle *)jarg1;
25580   if (!argp1) {
25581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25582     return 0;
25583   }
25584   arg1 = *argp1;
25585   {
25586     try {
25587       result = Dali::PropertyBuffer::DownCast(arg1);
25588     } catch (std::out_of_range& e) {
25589       {
25590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25591       };
25592     } catch (std::exception& e) {
25593       {
25594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25595       };
25596     } catch (Dali::DaliException e) {
25597       {
25598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25599       };
25600     } catch (...) {
25601       {
25602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25603       };
25604     }
25605   }
25606
25607   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25608   return jresult;
25609 }
25610
25611
25612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25613   void * jresult ;
25614   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25615   Dali::PropertyBuffer *arg2 = 0 ;
25616   Dali::PropertyBuffer *result = 0 ;
25617
25618   arg1 = (Dali::PropertyBuffer *)jarg1;
25619   arg2 = (Dali::PropertyBuffer *)jarg2;
25620   if (!arg2) {
25621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25622     return 0;
25623   }
25624   {
25625     try {
25626       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25627     } catch (std::out_of_range& e) {
25628       {
25629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25630       };
25631     } catch (std::exception& e) {
25632       {
25633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25634       };
25635     } catch (Dali::DaliException e) {
25636       {
25637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25638       };
25639     } catch (...) {
25640       {
25641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25642       };
25643     }
25644   }
25645
25646   jresult = (void *)result;
25647   return jresult;
25648 }
25649
25650
25651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25652   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25653   void *arg2 = (void *) 0 ;
25654   std::size_t arg3 ;
25655
25656   arg1 = (Dali::PropertyBuffer *)jarg1;
25657   arg2 = jarg2;
25658   arg3 = (std::size_t)jarg3;
25659   {
25660     try {
25661       (arg1)->SetData((void const *)arg2,arg3);
25662     } catch (std::out_of_range& e) {
25663       {
25664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25665       };
25666     } catch (std::exception& e) {
25667       {
25668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25669       };
25670     } catch (Dali::DaliException e) {
25671       {
25672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25673       };
25674     } catch (...) {
25675       {
25676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25677       };
25678     }
25679   }
25680
25681 }
25682
25683
25684 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25685   unsigned long jresult ;
25686   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25687   std::size_t result;
25688
25689   arg1 = (Dali::PropertyBuffer *)jarg1;
25690   {
25691     try {
25692       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25693     } catch (std::out_of_range& e) {
25694       {
25695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25696       };
25697     } catch (std::exception& e) {
25698       {
25699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25700       };
25701     } catch (Dali::DaliException e) {
25702       {
25703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25704       };
25705     } catch (...) {
25706       {
25707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25708       };
25709     }
25710   }
25711
25712   jresult = (unsigned long)result;
25713   return jresult;
25714 }
25715
25716
25717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25718   void * jresult ;
25719   Dali::Geometry result;
25720
25721   {
25722     try {
25723       result = Dali::Geometry::New();
25724     } catch (std::out_of_range& e) {
25725       {
25726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25727       };
25728     } catch (std::exception& e) {
25729       {
25730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25731       };
25732     } catch (Dali::DaliException e) {
25733       {
25734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25735       };
25736     } catch (...) {
25737       {
25738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25739       };
25740     }
25741   }
25742
25743   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25744   return jresult;
25745 }
25746
25747
25748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25749   void * jresult ;
25750   Dali::Geometry *result = 0 ;
25751
25752   {
25753     try {
25754       result = (Dali::Geometry *)new Dali::Geometry();
25755     } catch (std::out_of_range& e) {
25756       {
25757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25758       };
25759     } catch (std::exception& e) {
25760       {
25761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25762       };
25763     } catch (Dali::DaliException e) {
25764       {
25765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25766       };
25767     } catch (...) {
25768       {
25769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25770       };
25771     }
25772   }
25773
25774   jresult = (void *)result;
25775   return jresult;
25776 }
25777
25778
25779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25780   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25781
25782   arg1 = (Dali::Geometry *)jarg1;
25783   {
25784     try {
25785       delete arg1;
25786     } catch (std::out_of_range& e) {
25787       {
25788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25789       };
25790     } catch (std::exception& e) {
25791       {
25792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25793       };
25794     } catch (Dali::DaliException e) {
25795       {
25796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25797       };
25798     } catch (...) {
25799       {
25800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25801       };
25802     }
25803   }
25804
25805 }
25806
25807
25808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25809   void * jresult ;
25810   Dali::Geometry *arg1 = 0 ;
25811   Dali::Geometry *result = 0 ;
25812
25813   arg1 = (Dali::Geometry *)jarg1;
25814   if (!arg1) {
25815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25816     return 0;
25817   }
25818   {
25819     try {
25820       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25821     } catch (std::out_of_range& e) {
25822       {
25823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25824       };
25825     } catch (std::exception& e) {
25826       {
25827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25828       };
25829     } catch (Dali::DaliException e) {
25830       {
25831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25832       };
25833     } catch (...) {
25834       {
25835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25836       };
25837     }
25838   }
25839
25840   jresult = (void *)result;
25841   return jresult;
25842 }
25843
25844
25845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25846   void * jresult ;
25847   Dali::BaseHandle arg1 ;
25848   Dali::BaseHandle *argp1 ;
25849   Dali::Geometry result;
25850
25851   argp1 = (Dali::BaseHandle *)jarg1;
25852   if (!argp1) {
25853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25854     return 0;
25855   }
25856   arg1 = *argp1;
25857   {
25858     try {
25859       result = Dali::Geometry::DownCast(arg1);
25860     } catch (std::out_of_range& e) {
25861       {
25862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25863       };
25864     } catch (std::exception& e) {
25865       {
25866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25867       };
25868     } catch (Dali::DaliException e) {
25869       {
25870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25871       };
25872     } catch (...) {
25873       {
25874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25875       };
25876     }
25877   }
25878
25879   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25880   return jresult;
25881 }
25882
25883
25884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25885   void * jresult ;
25886   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25887   Dali::Geometry *arg2 = 0 ;
25888   Dali::Geometry *result = 0 ;
25889
25890   arg1 = (Dali::Geometry *)jarg1;
25891   arg2 = (Dali::Geometry *)jarg2;
25892   if (!arg2) {
25893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25894     return 0;
25895   }
25896   {
25897     try {
25898       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25899     } catch (std::out_of_range& e) {
25900       {
25901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25902       };
25903     } catch (std::exception& e) {
25904       {
25905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25906       };
25907     } catch (Dali::DaliException e) {
25908       {
25909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25910       };
25911     } catch (...) {
25912       {
25913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25914       };
25915     }
25916   }
25917
25918   jresult = (void *)result;
25919   return jresult;
25920 }
25921
25922
25923 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25924   unsigned long jresult ;
25925   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25926   Dali::PropertyBuffer *arg2 = 0 ;
25927   std::size_t result;
25928
25929   arg1 = (Dali::Geometry *)jarg1;
25930   arg2 = (Dali::PropertyBuffer *)jarg2;
25931   if (!arg2) {
25932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25933     return 0;
25934   }
25935   {
25936     try {
25937       result = (arg1)->AddVertexBuffer(*arg2);
25938     } catch (std::out_of_range& e) {
25939       {
25940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25941       };
25942     } catch (std::exception& e) {
25943       {
25944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25945       };
25946     } catch (Dali::DaliException e) {
25947       {
25948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25949       };
25950     } catch (...) {
25951       {
25952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25953       };
25954     }
25955   }
25956
25957   jresult = (unsigned long)result;
25958   return jresult;
25959 }
25960
25961
25962 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25963   unsigned long jresult ;
25964   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25965   std::size_t result;
25966
25967   arg1 = (Dali::Geometry *)jarg1;
25968   {
25969     try {
25970       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25971     } catch (std::out_of_range& e) {
25972       {
25973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25974       };
25975     } catch (std::exception& e) {
25976       {
25977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25978       };
25979     } catch (Dali::DaliException e) {
25980       {
25981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25982       };
25983     } catch (...) {
25984       {
25985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25986       };
25987     }
25988   }
25989
25990   jresult = (unsigned long)result;
25991   return jresult;
25992 }
25993
25994
25995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25996   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25997   std::size_t arg2 ;
25998
25999   arg1 = (Dali::Geometry *)jarg1;
26000   arg2 = (std::size_t)jarg2;
26001   {
26002     try {
26003       (arg1)->RemoveVertexBuffer(arg2);
26004     } catch (std::out_of_range& e) {
26005       {
26006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26007       };
26008     } catch (std::exception& e) {
26009       {
26010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26011       };
26012     } catch (Dali::DaliException e) {
26013       {
26014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26015       };
26016     } catch (...) {
26017       {
26018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26019       };
26020     }
26021   }
26022
26023 }
26024
26025
26026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26027   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26028   unsigned short *arg2 = (unsigned short *) 0 ;
26029   size_t arg3 ;
26030
26031   arg1 = (Dali::Geometry *)jarg1;
26032   arg2 = jarg2;
26033   arg3 = (size_t)jarg3;
26034   {
26035     try {
26036       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26037     } catch (std::out_of_range& e) {
26038       {
26039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26040       };
26041     } catch (std::exception& e) {
26042       {
26043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26044       };
26045     } catch (Dali::DaliException e) {
26046       {
26047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26048       };
26049     } catch (...) {
26050       {
26051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26052       };
26053     }
26054   }
26055
26056
26057
26058 }
26059
26060
26061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26062   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26063   Dali::Geometry::Type arg2 ;
26064
26065   arg1 = (Dali::Geometry *)jarg1;
26066   arg2 = (Dali::Geometry::Type)jarg2;
26067   {
26068     try {
26069       (arg1)->SetType(arg2);
26070     } catch (std::out_of_range& e) {
26071       {
26072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26073       };
26074     } catch (std::exception& e) {
26075       {
26076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26077       };
26078     } catch (Dali::DaliException e) {
26079       {
26080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26081       };
26082     } catch (...) {
26083       {
26084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26085       };
26086     }
26087   }
26088
26089 }
26090
26091
26092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26093   int jresult ;
26094   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26095   Dali::Geometry::Type result;
26096
26097   arg1 = (Dali::Geometry *)jarg1;
26098   {
26099     try {
26100       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26101     } catch (std::out_of_range& e) {
26102       {
26103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26104       };
26105     } catch (std::exception& e) {
26106       {
26107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26108       };
26109     } catch (Dali::DaliException e) {
26110       {
26111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26112       };
26113     } catch (...) {
26114       {
26115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26116       };
26117     }
26118   }
26119
26120   jresult = (int)result;
26121   return jresult;
26122 }
26123
26124
26125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26126   void * jresult ;
26127   Dali::Shader::Hint *result = 0 ;
26128
26129   {
26130     try {
26131       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26132     } catch (std::out_of_range& e) {
26133       {
26134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26135       };
26136     } catch (std::exception& e) {
26137       {
26138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26139       };
26140     } catch (Dali::DaliException e) {
26141       {
26142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26143       };
26144     } catch (...) {
26145       {
26146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26147       };
26148     }
26149   }
26150
26151   jresult = (void *)result;
26152   return jresult;
26153 }
26154
26155
26156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26157   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26158
26159   arg1 = (Dali::Shader::Hint *)jarg1;
26160   {
26161     try {
26162       delete arg1;
26163     } catch (std::out_of_range& e) {
26164       {
26165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26166       };
26167     } catch (std::exception& e) {
26168       {
26169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26170       };
26171     } catch (Dali::DaliException e) {
26172       {
26173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26174       };
26175     } catch (...) {
26176       {
26177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26178       };
26179     }
26180   }
26181
26182 }
26183
26184
26185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26186   int jresult ;
26187   int result;
26188
26189   result = (int)Dali::Shader::Property::PROGRAM;
26190   jresult = (int)result;
26191   return jresult;
26192 }
26193
26194
26195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26196   void * jresult ;
26197   Dali::Shader::Property *result = 0 ;
26198
26199   {
26200     try {
26201       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26202     } catch (std::out_of_range& e) {
26203       {
26204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26205       };
26206     } catch (std::exception& e) {
26207       {
26208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26209       };
26210     } catch (Dali::DaliException e) {
26211       {
26212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26213       };
26214     } catch (...) {
26215       {
26216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26217       };
26218     }
26219   }
26220
26221   jresult = (void *)result;
26222   return jresult;
26223 }
26224
26225
26226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26227   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26228
26229   arg1 = (Dali::Shader::Property *)jarg1;
26230   {
26231     try {
26232       delete arg1;
26233     } catch (std::out_of_range& e) {
26234       {
26235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26236       };
26237     } catch (std::exception& e) {
26238       {
26239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26240       };
26241     } catch (Dali::DaliException e) {
26242       {
26243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26244       };
26245     } catch (...) {
26246       {
26247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26248       };
26249     }
26250   }
26251
26252 }
26253
26254
26255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26256   void * jresult ;
26257   std::string *arg1 = 0 ;
26258   std::string *arg2 = 0 ;
26259   Dali::Shader::Hint::Value arg3 ;
26260   Dali::Shader result;
26261
26262   if (!jarg1) {
26263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26264     return 0;
26265   }
26266   std::string arg1_str(jarg1);
26267   arg1 = &arg1_str;
26268   if (!jarg2) {
26269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26270     return 0;
26271   }
26272   std::string arg2_str(jarg2);
26273   arg2 = &arg2_str;
26274   arg3 = (Dali::Shader::Hint::Value)jarg3;
26275   {
26276     try {
26277       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26278     } catch (std::out_of_range& e) {
26279       {
26280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26281       };
26282     } catch (std::exception& e) {
26283       {
26284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26285       };
26286     } catch (Dali::DaliException e) {
26287       {
26288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26289       };
26290     } catch (...) {
26291       {
26292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26293       };
26294     }
26295   }
26296
26297   jresult = new Dali::Shader((const Dali::Shader &)result);
26298
26299   //argout typemap for const std::string&
26300
26301
26302   //argout typemap for const std::string&
26303
26304   return jresult;
26305 }
26306
26307
26308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26309   void * jresult ;
26310   std::string *arg1 = 0 ;
26311   std::string *arg2 = 0 ;
26312   Dali::Shader result;
26313
26314   if (!jarg1) {
26315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26316     return 0;
26317   }
26318   std::string arg1_str(jarg1);
26319   arg1 = &arg1_str;
26320   if (!jarg2) {
26321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26322     return 0;
26323   }
26324   std::string arg2_str(jarg2);
26325   arg2 = &arg2_str;
26326   {
26327     try {
26328       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26329     } catch (std::out_of_range& e) {
26330       {
26331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26332       };
26333     } catch (std::exception& e) {
26334       {
26335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26336       };
26337     } catch (Dali::DaliException e) {
26338       {
26339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26340       };
26341     } catch (...) {
26342       {
26343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26344       };
26345     }
26346   }
26347
26348   jresult = new Dali::Shader((const Dali::Shader &)result);
26349
26350   //argout typemap for const std::string&
26351
26352
26353   //argout typemap for const std::string&
26354
26355   return jresult;
26356 }
26357
26358
26359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26360   void * jresult ;
26361   Dali::Shader *result = 0 ;
26362
26363   {
26364     try {
26365       result = (Dali::Shader *)new Dali::Shader();
26366     } catch (std::out_of_range& e) {
26367       {
26368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26369       };
26370     } catch (std::exception& e) {
26371       {
26372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26373       };
26374     } catch (Dali::DaliException e) {
26375       {
26376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26377       };
26378     } catch (...) {
26379       {
26380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26381       };
26382     }
26383   }
26384
26385   jresult = (void *)result;
26386   return jresult;
26387 }
26388
26389
26390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26391   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26392
26393   arg1 = (Dali::Shader *)jarg1;
26394   {
26395     try {
26396       delete arg1;
26397     } catch (std::out_of_range& e) {
26398       {
26399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26400       };
26401     } catch (std::exception& e) {
26402       {
26403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26404       };
26405     } catch (Dali::DaliException e) {
26406       {
26407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26408       };
26409     } catch (...) {
26410       {
26411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26412       };
26413     }
26414   }
26415
26416 }
26417
26418
26419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26420   void * jresult ;
26421   Dali::Shader *arg1 = 0 ;
26422   Dali::Shader *result = 0 ;
26423
26424   arg1 = (Dali::Shader *)jarg1;
26425   if (!arg1) {
26426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26427     return 0;
26428   }
26429   {
26430     try {
26431       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26432     } catch (std::out_of_range& e) {
26433       {
26434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26435       };
26436     } catch (std::exception& e) {
26437       {
26438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26439       };
26440     } catch (Dali::DaliException e) {
26441       {
26442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26443       };
26444     } catch (...) {
26445       {
26446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26447       };
26448     }
26449   }
26450
26451   jresult = (void *)result;
26452   return jresult;
26453 }
26454
26455
26456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26457   void * jresult ;
26458   Dali::BaseHandle arg1 ;
26459   Dali::BaseHandle *argp1 ;
26460   Dali::Shader result;
26461
26462   argp1 = (Dali::BaseHandle *)jarg1;
26463   if (!argp1) {
26464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26465     return 0;
26466   }
26467   arg1 = *argp1;
26468   {
26469     try {
26470       result = Dali::Shader::DownCast(arg1);
26471     } catch (std::out_of_range& e) {
26472       {
26473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26474       };
26475     } catch (std::exception& e) {
26476       {
26477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26478       };
26479     } catch (Dali::DaliException e) {
26480       {
26481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26482       };
26483     } catch (...) {
26484       {
26485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26486       };
26487     }
26488   }
26489
26490   jresult = new Dali::Shader((const Dali::Shader &)result);
26491   return jresult;
26492 }
26493
26494
26495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26496   void * jresult ;
26497   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26498   Dali::Shader *arg2 = 0 ;
26499   Dali::Shader *result = 0 ;
26500
26501   arg1 = (Dali::Shader *)jarg1;
26502   arg2 = (Dali::Shader *)jarg2;
26503   if (!arg2) {
26504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26505     return 0;
26506   }
26507   {
26508     try {
26509       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26510     } catch (std::out_of_range& e) {
26511       {
26512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26513       };
26514     } catch (std::exception& e) {
26515       {
26516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26517       };
26518     } catch (Dali::DaliException e) {
26519       {
26520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26521       };
26522     } catch (...) {
26523       {
26524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26525       };
26526     }
26527   }
26528
26529   jresult = (void *)result;
26530   return jresult;
26531 }
26532
26533
26534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26535   int jresult ;
26536   int result;
26537
26538   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26539   jresult = (int)result;
26540   return jresult;
26541 }
26542
26543
26544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26545   int jresult ;
26546   int result;
26547
26548   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26549   jresult = (int)result;
26550   return jresult;
26551 }
26552
26553
26554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26555   int jresult ;
26556   int result;
26557
26558   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26559   jresult = (int)result;
26560   return jresult;
26561 }
26562
26563
26564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26565   int jresult ;
26566   int result;
26567
26568   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26569   jresult = (int)result;
26570   return jresult;
26571 }
26572
26573
26574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26575   int jresult ;
26576   int result;
26577
26578   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26579   jresult = (int)result;
26580   return jresult;
26581 }
26582
26583
26584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26585   int jresult ;
26586   int result;
26587
26588   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26589   jresult = (int)result;
26590   return jresult;
26591 }
26592
26593
26594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26595   int jresult ;
26596   int result;
26597
26598   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26599   jresult = (int)result;
26600   return jresult;
26601 }
26602
26603
26604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26605   int jresult ;
26606   int result;
26607
26608   result = (int)Dali::Renderer::Property::BLEND_MODE;
26609   jresult = (int)result;
26610   return jresult;
26611 }
26612
26613
26614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26615   int jresult ;
26616   int result;
26617
26618   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26619   jresult = (int)result;
26620   return jresult;
26621 }
26622
26623
26624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26625   int jresult ;
26626   int result;
26627
26628   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26629   jresult = (int)result;
26630   return jresult;
26631 }
26632
26633
26634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26635   int jresult ;
26636   int result;
26637
26638   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26639   jresult = (int)result;
26640   return jresult;
26641 }
26642
26643
26644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26645   int jresult ;
26646   int result;
26647
26648   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26649   jresult = (int)result;
26650   return jresult;
26651 }
26652
26653
26654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26655   int jresult ;
26656   int result;
26657
26658   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26659   jresult = (int)result;
26660   return jresult;
26661 }
26662
26663
26664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26665   int jresult ;
26666   int result;
26667
26668   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26669   jresult = (int)result;
26670   return jresult;
26671 }
26672
26673
26674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26675   int jresult ;
26676   int result;
26677
26678   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26679   jresult = (int)result;
26680   return jresult;
26681 }
26682
26683
26684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26685   int jresult ;
26686   int result;
26687
26688   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26689   jresult = (int)result;
26690   return jresult;
26691 }
26692
26693
26694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26695   int jresult ;
26696   int result;
26697
26698   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26699   jresult = (int)result;
26700   return jresult;
26701 }
26702
26703
26704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26705   int jresult ;
26706   int result;
26707
26708   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26709   jresult = (int)result;
26710   return jresult;
26711 }
26712
26713
26714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26715   int jresult ;
26716   int result;
26717
26718   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26719   jresult = (int)result;
26720   return jresult;
26721 }
26722
26723
26724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26725   int jresult ;
26726   int result;
26727
26728   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26729   jresult = (int)result;
26730   return jresult;
26731 }
26732
26733
26734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26735   int jresult ;
26736   int result;
26737
26738   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26739   jresult = (int)result;
26740   return jresult;
26741 }
26742
26743
26744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26745   int jresult ;
26746   int result;
26747
26748   result = (int)Dali::Renderer::Property::RENDER_MODE;
26749   jresult = (int)result;
26750   return jresult;
26751 }
26752
26753
26754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26755   int jresult ;
26756   int result;
26757
26758   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26759   jresult = (int)result;
26760   return jresult;
26761 }
26762
26763
26764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26765   int jresult ;
26766   int result;
26767
26768   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26769   jresult = (int)result;
26770   return jresult;
26771 }
26772
26773
26774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26775   int jresult ;
26776   int result;
26777
26778   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26779   jresult = (int)result;
26780   return jresult;
26781 }
26782
26783
26784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26785   int jresult ;
26786   int result;
26787
26788   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26789   jresult = (int)result;
26790   return jresult;
26791 }
26792
26793
26794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26795   int jresult ;
26796   int result;
26797
26798   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26799   jresult = (int)result;
26800   return jresult;
26801 }
26802
26803
26804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26805   int jresult ;
26806   int result;
26807
26808   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26809   jresult = (int)result;
26810   return jresult;
26811 }
26812
26813
26814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26815   int jresult ;
26816   int result;
26817
26818   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26819   jresult = (int)result;
26820   return jresult;
26821 }
26822
26823
26824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26825   void * jresult ;
26826   Dali::Renderer::Property *result = 0 ;
26827
26828   {
26829     try {
26830       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26831     } catch (std::out_of_range& e) {
26832       {
26833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26834       };
26835     } catch (std::exception& e) {
26836       {
26837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26838       };
26839     } catch (Dali::DaliException e) {
26840       {
26841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26842       };
26843     } catch (...) {
26844       {
26845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26846       };
26847     }
26848   }
26849
26850   jresult = (void *)result;
26851   return jresult;
26852 }
26853
26854
26855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26856   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26857
26858   arg1 = (Dali::Renderer::Property *)jarg1;
26859   {
26860     try {
26861       delete arg1;
26862     } catch (std::out_of_range& e) {
26863       {
26864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26865       };
26866     } catch (std::exception& e) {
26867       {
26868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26869       };
26870     } catch (Dali::DaliException e) {
26871       {
26872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26873       };
26874     } catch (...) {
26875       {
26876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26877       };
26878     }
26879   }
26880
26881 }
26882
26883
26884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26885   void * jresult ;
26886   Dali::Geometry *arg1 = 0 ;
26887   Dali::Shader *arg2 = 0 ;
26888   Dali::Renderer result;
26889
26890   arg1 = (Dali::Geometry *)jarg1;
26891   if (!arg1) {
26892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26893     return 0;
26894   }
26895   arg2 = (Dali::Shader *)jarg2;
26896   if (!arg2) {
26897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26898     return 0;
26899   }
26900   {
26901     try {
26902       result = Dali::Renderer::New(*arg1,*arg2);
26903     } catch (std::out_of_range& e) {
26904       {
26905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26906       };
26907     } catch (std::exception& e) {
26908       {
26909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26910       };
26911     } catch (Dali::DaliException e) {
26912       {
26913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26914       };
26915     } catch (...) {
26916       {
26917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26918       };
26919     }
26920   }
26921
26922   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26923   return jresult;
26924 }
26925
26926
26927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26928   void * jresult ;
26929   Dali::Renderer *result = 0 ;
26930
26931   {
26932     try {
26933       result = (Dali::Renderer *)new Dali::Renderer();
26934     } catch (std::out_of_range& e) {
26935       {
26936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26937       };
26938     } catch (std::exception& e) {
26939       {
26940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26941       };
26942     } catch (Dali::DaliException e) {
26943       {
26944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26945       };
26946     } catch (...) {
26947       {
26948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26949       };
26950     }
26951   }
26952
26953   jresult = (void *)result;
26954   return jresult;
26955 }
26956
26957
26958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26959   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26960
26961   arg1 = (Dali::Renderer *)jarg1;
26962   {
26963     try {
26964       delete arg1;
26965     } catch (std::out_of_range& e) {
26966       {
26967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26968       };
26969     } catch (std::exception& e) {
26970       {
26971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26972       };
26973     } catch (Dali::DaliException e) {
26974       {
26975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26976       };
26977     } catch (...) {
26978       {
26979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26980       };
26981     }
26982   }
26983
26984 }
26985
26986
26987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26988   void * jresult ;
26989   Dali::Renderer *arg1 = 0 ;
26990   Dali::Renderer *result = 0 ;
26991
26992   arg1 = (Dali::Renderer *)jarg1;
26993   if (!arg1) {
26994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26995     return 0;
26996   }
26997   {
26998     try {
26999       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
27000     } catch (std::out_of_range& e) {
27001       {
27002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27003       };
27004     } catch (std::exception& e) {
27005       {
27006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27007       };
27008     } catch (Dali::DaliException e) {
27009       {
27010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27011       };
27012     } catch (...) {
27013       {
27014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27015       };
27016     }
27017   }
27018
27019   jresult = (void *)result;
27020   return jresult;
27021 }
27022
27023
27024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
27025   void * jresult ;
27026   Dali::BaseHandle arg1 ;
27027   Dali::BaseHandle *argp1 ;
27028   Dali::Renderer result;
27029
27030   argp1 = (Dali::BaseHandle *)jarg1;
27031   if (!argp1) {
27032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27033     return 0;
27034   }
27035   arg1 = *argp1;
27036   {
27037     try {
27038       result = Dali::Renderer::DownCast(arg1);
27039     } catch (std::out_of_range& e) {
27040       {
27041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27042       };
27043     } catch (std::exception& e) {
27044       {
27045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27046       };
27047     } catch (Dali::DaliException e) {
27048       {
27049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27050       };
27051     } catch (...) {
27052       {
27053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27054       };
27055     }
27056   }
27057
27058   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27059   return jresult;
27060 }
27061
27062
27063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27064   void * jresult ;
27065   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27066   Dali::Renderer *arg2 = 0 ;
27067   Dali::Renderer *result = 0 ;
27068
27069   arg1 = (Dali::Renderer *)jarg1;
27070   arg2 = (Dali::Renderer *)jarg2;
27071   if (!arg2) {
27072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27073     return 0;
27074   }
27075   {
27076     try {
27077       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27078     } catch (std::out_of_range& e) {
27079       {
27080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27081       };
27082     } catch (std::exception& e) {
27083       {
27084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27085       };
27086     } catch (Dali::DaliException e) {
27087       {
27088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27089       };
27090     } catch (...) {
27091       {
27092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27093       };
27094     }
27095   }
27096
27097   jresult = (void *)result;
27098   return jresult;
27099 }
27100
27101
27102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27103   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27104   Dali::Geometry *arg2 = 0 ;
27105
27106   arg1 = (Dali::Renderer *)jarg1;
27107   arg2 = (Dali::Geometry *)jarg2;
27108   if (!arg2) {
27109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27110     return ;
27111   }
27112   {
27113     try {
27114       (arg1)->SetGeometry(*arg2);
27115     } catch (std::out_of_range& e) {
27116       {
27117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27118       };
27119     } catch (std::exception& e) {
27120       {
27121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27122       };
27123     } catch (Dali::DaliException e) {
27124       {
27125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27126       };
27127     } catch (...) {
27128       {
27129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27130       };
27131     }
27132   }
27133
27134 }
27135
27136
27137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27138   void * jresult ;
27139   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27140   Dali::Geometry result;
27141
27142   arg1 = (Dali::Renderer *)jarg1;
27143   {
27144     try {
27145       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27146     } catch (std::out_of_range& e) {
27147       {
27148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27149       };
27150     } catch (std::exception& e) {
27151       {
27152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27153       };
27154     } catch (Dali::DaliException e) {
27155       {
27156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27157       };
27158     } catch (...) {
27159       {
27160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27161       };
27162     }
27163   }
27164
27165   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27166   return jresult;
27167 }
27168
27169
27170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27171   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27172   int arg2 ;
27173   int arg3 ;
27174
27175   arg1 = (Dali::Renderer *)jarg1;
27176   arg2 = (int)jarg2;
27177   arg3 = (int)jarg3;
27178   {
27179     try {
27180       (arg1)->SetIndexRange(arg2,arg3);
27181     } catch (std::out_of_range& e) {
27182       {
27183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27184       };
27185     } catch (std::exception& e) {
27186       {
27187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27188       };
27189     } catch (Dali::DaliException e) {
27190       {
27191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27192       };
27193     } catch (...) {
27194       {
27195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27196       };
27197     }
27198   }
27199
27200 }
27201
27202
27203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27204   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27205   Dali::TextureSet *arg2 = 0 ;
27206
27207   arg1 = (Dali::Renderer *)jarg1;
27208   arg2 = (Dali::TextureSet *)jarg2;
27209   if (!arg2) {
27210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27211     return ;
27212   }
27213   {
27214     try {
27215       (arg1)->SetTextures(*arg2);
27216     } catch (std::out_of_range& e) {
27217       {
27218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27219       };
27220     } catch (std::exception& e) {
27221       {
27222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27223       };
27224     } catch (Dali::DaliException e) {
27225       {
27226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27227       };
27228     } catch (...) {
27229       {
27230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27231       };
27232     }
27233   }
27234
27235 }
27236
27237
27238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27239   void * jresult ;
27240   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27241   Dali::TextureSet result;
27242
27243   arg1 = (Dali::Renderer *)jarg1;
27244   {
27245     try {
27246       result = ((Dali::Renderer const *)arg1)->GetTextures();
27247     } catch (std::out_of_range& e) {
27248       {
27249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27250       };
27251     } catch (std::exception& e) {
27252       {
27253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27254       };
27255     } catch (Dali::DaliException e) {
27256       {
27257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27258       };
27259     } catch (...) {
27260       {
27261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27262       };
27263     }
27264   }
27265
27266   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27267   return jresult;
27268 }
27269
27270
27271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27272   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27273   Dali::Shader *arg2 = 0 ;
27274
27275   arg1 = (Dali::Renderer *)jarg1;
27276   arg2 = (Dali::Shader *)jarg2;
27277   if (!arg2) {
27278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27279     return ;
27280   }
27281   {
27282     try {
27283       (arg1)->SetShader(*arg2);
27284     } catch (std::out_of_range& e) {
27285       {
27286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27287       };
27288     } catch (std::exception& e) {
27289       {
27290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27291       };
27292     } catch (Dali::DaliException e) {
27293       {
27294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27295       };
27296     } catch (...) {
27297       {
27298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27299       };
27300     }
27301   }
27302
27303 }
27304
27305
27306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27307   void * jresult ;
27308   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27309   Dali::Shader result;
27310
27311   arg1 = (Dali::Renderer *)jarg1;
27312   {
27313     try {
27314       result = ((Dali::Renderer const *)arg1)->GetShader();
27315     } catch (std::out_of_range& e) {
27316       {
27317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27318       };
27319     } catch (std::exception& e) {
27320       {
27321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27322       };
27323     } catch (Dali::DaliException e) {
27324       {
27325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27326       };
27327     } catch (...) {
27328       {
27329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27330       };
27331     }
27332   }
27333
27334   jresult = new Dali::Shader((const Dali::Shader &)result);
27335   return jresult;
27336 }
27337
27338
27339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27340   void * jresult ;
27341   Dali::FrameBuffer::Attachment *result = 0 ;
27342
27343   {
27344     try {
27345       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27346     } catch (std::out_of_range& e) {
27347       {
27348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27349       };
27350     } catch (std::exception& e) {
27351       {
27352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27353       };
27354     } catch (Dali::DaliException e) {
27355       {
27356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27357       };
27358     } catch (...) {
27359       {
27360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27361       };
27362     }
27363   }
27364
27365   jresult = (void *)result;
27366   return jresult;
27367 }
27368
27369
27370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27371   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27372
27373   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27374   {
27375     try {
27376       delete arg1;
27377     } catch (std::out_of_range& e) {
27378       {
27379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27380       };
27381     } catch (std::exception& e) {
27382       {
27383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27384       };
27385     } catch (Dali::DaliException e) {
27386       {
27387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27388       };
27389     } catch (...) {
27390       {
27391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27392       };
27393     }
27394   }
27395
27396 }
27397
27398
27399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27400   void * jresult ;
27401   unsigned int arg1 ;
27402   unsigned int arg2 ;
27403   unsigned int arg3 ;
27404   Dali::FrameBuffer result;
27405
27406   arg1 = (unsigned int)jarg1;
27407   arg2 = (unsigned int)jarg2;
27408   arg3 = (unsigned int)jarg3;
27409   {
27410     try {
27411       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27412     } catch (std::out_of_range& e) {
27413       {
27414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27415       };
27416     } catch (std::exception& e) {
27417       {
27418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27419       };
27420     } catch (Dali::DaliException e) {
27421       {
27422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27423       };
27424     } catch (...) {
27425       {
27426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27427       };
27428     }
27429   }
27430
27431   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27432   return jresult;
27433 }
27434
27435
27436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27437   void * jresult ;
27438   Dali::FrameBuffer *result = 0 ;
27439
27440   {
27441     try {
27442       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27443     } catch (std::out_of_range& e) {
27444       {
27445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27446       };
27447     } catch (std::exception& e) {
27448       {
27449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27450       };
27451     } catch (Dali::DaliException e) {
27452       {
27453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27454       };
27455     } catch (...) {
27456       {
27457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27458       };
27459     }
27460   }
27461
27462   jresult = (void *)result;
27463   return jresult;
27464 }
27465
27466
27467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27468   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27469
27470   arg1 = (Dali::FrameBuffer *)jarg1;
27471   {
27472     try {
27473       delete arg1;
27474     } catch (std::out_of_range& e) {
27475       {
27476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27477       };
27478     } catch (std::exception& e) {
27479       {
27480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27481       };
27482     } catch (Dali::DaliException e) {
27483       {
27484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27485       };
27486     } catch (...) {
27487       {
27488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27489       };
27490     }
27491   }
27492
27493 }
27494
27495
27496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27497   void * jresult ;
27498   Dali::FrameBuffer *arg1 = 0 ;
27499   Dali::FrameBuffer *result = 0 ;
27500
27501   arg1 = (Dali::FrameBuffer *)jarg1;
27502   if (!arg1) {
27503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27504     return 0;
27505   }
27506   {
27507     try {
27508       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27509     } catch (std::out_of_range& e) {
27510       {
27511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27512       };
27513     } catch (std::exception& e) {
27514       {
27515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27516       };
27517     } catch (Dali::DaliException e) {
27518       {
27519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27520       };
27521     } catch (...) {
27522       {
27523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27524       };
27525     }
27526   }
27527
27528   jresult = (void *)result;
27529   return jresult;
27530 }
27531
27532
27533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27534   void * jresult ;
27535   Dali::BaseHandle arg1 ;
27536   Dali::BaseHandle *argp1 ;
27537   Dali::FrameBuffer result;
27538
27539   argp1 = (Dali::BaseHandle *)jarg1;
27540   if (!argp1) {
27541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27542     return 0;
27543   }
27544   arg1 = *argp1;
27545   {
27546     try {
27547       result = Dali::FrameBuffer::DownCast(arg1);
27548     } catch (std::out_of_range& e) {
27549       {
27550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27551       };
27552     } catch (std::exception& e) {
27553       {
27554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27555       };
27556     } catch (Dali::DaliException e) {
27557       {
27558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27559       };
27560     } catch (...) {
27561       {
27562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27563       };
27564     }
27565   }
27566
27567   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27568   return jresult;
27569 }
27570
27571
27572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27573   void * jresult ;
27574   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27575   Dali::FrameBuffer *arg2 = 0 ;
27576   Dali::FrameBuffer *result = 0 ;
27577
27578   arg1 = (Dali::FrameBuffer *)jarg1;
27579   arg2 = (Dali::FrameBuffer *)jarg2;
27580   if (!arg2) {
27581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27582     return 0;
27583   }
27584   {
27585     try {
27586       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27587     } catch (std::out_of_range& e) {
27588       {
27589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27590       };
27591     } catch (std::exception& e) {
27592       {
27593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27594       };
27595     } catch (Dali::DaliException e) {
27596       {
27597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27598       };
27599     } catch (...) {
27600       {
27601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27602       };
27603     }
27604   }
27605
27606   jresult = (void *)result;
27607   return jresult;
27608 }
27609
27610
27611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27612   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27613   Dali::Texture *arg2 = 0 ;
27614
27615   arg1 = (Dali::FrameBuffer *)jarg1;
27616   arg2 = (Dali::Texture *)jarg2;
27617   if (!arg2) {
27618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27619     return ;
27620   }
27621   {
27622     try {
27623       (arg1)->AttachColorTexture(*arg2);
27624     } catch (std::out_of_range& e) {
27625       {
27626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27627       };
27628     } catch (std::exception& e) {
27629       {
27630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27631       };
27632     } catch (Dali::DaliException e) {
27633       {
27634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27635       };
27636     } catch (...) {
27637       {
27638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27639       };
27640     }
27641   }
27642
27643 }
27644
27645
27646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27647   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27648   Dali::Texture *arg2 = 0 ;
27649   unsigned int arg3 ;
27650   unsigned int arg4 ;
27651
27652   arg1 = (Dali::FrameBuffer *)jarg1;
27653   arg2 = (Dali::Texture *)jarg2;
27654   if (!arg2) {
27655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27656     return ;
27657   }
27658   arg3 = (unsigned int)jarg3;
27659   arg4 = (unsigned int)jarg4;
27660   {
27661     try {
27662       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27663     } catch (std::out_of_range& e) {
27664       {
27665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27666       };
27667     } catch (std::exception& e) {
27668       {
27669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27670       };
27671     } catch (Dali::DaliException e) {
27672       {
27673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27674       };
27675     } catch (...) {
27676       {
27677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27678       };
27679     }
27680   }
27681
27682 }
27683
27684
27685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27686   void * jresult ;
27687   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27688   Dali::Texture result;
27689
27690   arg1 = (Dali::FrameBuffer *)jarg1;
27691   {
27692     try {
27693       result = (arg1)->GetColorTexture();
27694     } catch (std::out_of_range& e) {
27695       {
27696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27697       };
27698     } catch (std::exception& e) {
27699       {
27700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27701       };
27702     } catch (Dali::DaliException e) {
27703       {
27704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27705       };
27706     } catch (...) {
27707       {
27708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27709       };
27710     }
27711   }
27712
27713   jresult = new Dali::Texture((const Dali::Texture &)result);
27714   return jresult;
27715 }
27716
27717
27718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27719   void * jresult ;
27720   Dali::RenderTaskList *result = 0 ;
27721
27722   {
27723     try {
27724       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27725     } catch (std::out_of_range& e) {
27726       {
27727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27728       };
27729     } catch (std::exception& e) {
27730       {
27731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27732       };
27733     } catch (Dali::DaliException e) {
27734       {
27735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27736       };
27737     } catch (...) {
27738       {
27739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27740       };
27741     }
27742   }
27743
27744   jresult = (void *)result;
27745   return jresult;
27746 }
27747
27748
27749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27750   void * jresult ;
27751   Dali::BaseHandle arg1 ;
27752   Dali::BaseHandle *argp1 ;
27753   Dali::RenderTaskList result;
27754
27755   argp1 = (Dali::BaseHandle *)jarg1;
27756   if (!argp1) {
27757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27758     return 0;
27759   }
27760   arg1 = *argp1;
27761   {
27762     try {
27763       result = Dali::RenderTaskList::DownCast(arg1);
27764     } catch (std::out_of_range& e) {
27765       {
27766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27767       };
27768     } catch (std::exception& e) {
27769       {
27770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27771       };
27772     } catch (Dali::DaliException e) {
27773       {
27774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27775       };
27776     } catch (...) {
27777       {
27778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27779       };
27780     }
27781   }
27782
27783   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27784   return jresult;
27785 }
27786
27787
27788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27789   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27790
27791   arg1 = (Dali::RenderTaskList *)jarg1;
27792   {
27793     try {
27794       delete arg1;
27795     } catch (std::out_of_range& e) {
27796       {
27797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27798       };
27799     } catch (std::exception& e) {
27800       {
27801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27802       };
27803     } catch (Dali::DaliException e) {
27804       {
27805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27806       };
27807     } catch (...) {
27808       {
27809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27810       };
27811     }
27812   }
27813
27814 }
27815
27816
27817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27818   void * jresult ;
27819   Dali::RenderTaskList *arg1 = 0 ;
27820   Dali::RenderTaskList *result = 0 ;
27821
27822   arg1 = (Dali::RenderTaskList *)jarg1;
27823   if (!arg1) {
27824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27825     return 0;
27826   }
27827   {
27828     try {
27829       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27830     } catch (std::out_of_range& e) {
27831       {
27832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27833       };
27834     } catch (std::exception& e) {
27835       {
27836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27837       };
27838     } catch (Dali::DaliException e) {
27839       {
27840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27841       };
27842     } catch (...) {
27843       {
27844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27845       };
27846     }
27847   }
27848
27849   jresult = (void *)result;
27850   return jresult;
27851 }
27852
27853
27854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27855   void * jresult ;
27856   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27857   Dali::RenderTaskList *arg2 = 0 ;
27858   Dali::RenderTaskList *result = 0 ;
27859
27860   arg1 = (Dali::RenderTaskList *)jarg1;
27861   arg2 = (Dali::RenderTaskList *)jarg2;
27862   if (!arg2) {
27863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27864     return 0;
27865   }
27866   {
27867     try {
27868       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27869     } catch (std::out_of_range& e) {
27870       {
27871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27872       };
27873     } catch (std::exception& e) {
27874       {
27875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27876       };
27877     } catch (Dali::DaliException e) {
27878       {
27879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27880       };
27881     } catch (...) {
27882       {
27883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27884       };
27885     }
27886   }
27887
27888   jresult = (void *)result;
27889   return jresult;
27890 }
27891
27892
27893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27894   void * jresult ;
27895   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27896   Dali::RenderTask result;
27897
27898   arg1 = (Dali::RenderTaskList *)jarg1;
27899   {
27900     try {
27901       result = (arg1)->CreateTask();
27902     } catch (std::out_of_range& e) {
27903       {
27904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27905       };
27906     } catch (std::exception& e) {
27907       {
27908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27909       };
27910     } catch (Dali::DaliException e) {
27911       {
27912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27913       };
27914     } catch (...) {
27915       {
27916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27917       };
27918     }
27919   }
27920
27921   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27922   return jresult;
27923 }
27924
27925
27926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27927   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27928   Dali::RenderTask arg2 ;
27929   Dali::RenderTask *argp2 ;
27930
27931   arg1 = (Dali::RenderTaskList *)jarg1;
27932   argp2 = (Dali::RenderTask *)jarg2;
27933   if (!argp2) {
27934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27935     return ;
27936   }
27937   arg2 = *argp2;
27938   {
27939     try {
27940       (arg1)->RemoveTask(arg2);
27941     } catch (std::out_of_range& e) {
27942       {
27943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27944       };
27945     } catch (std::exception& e) {
27946       {
27947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27948       };
27949     } catch (Dali::DaliException e) {
27950       {
27951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27952       };
27953     } catch (...) {
27954       {
27955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27956       };
27957     }
27958   }
27959
27960 }
27961
27962
27963 //// ===============================================end part 1 =================
27964
27965 //// ========================= part 2 ===============================
27966
27967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27968   unsigned int jresult ;
27969   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27970   unsigned int result;
27971
27972   arg1 = (Dali::RenderTaskList *)jarg1;
27973   {
27974     try {
27975       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27976     } catch (std::out_of_range& e) {
27977       {
27978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27979       };
27980     } catch (std::exception& e) {
27981       {
27982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27983       };
27984     } catch (Dali::DaliException e) {
27985       {
27986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27987       };
27988     } catch (...) {
27989       {
27990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27991       };
27992     }
27993   }
27994
27995   jresult = result;
27996   return jresult;
27997 }
27998
27999
28000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
28001   void * jresult ;
28002   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28003   unsigned int arg2 ;
28004   Dali::RenderTask result;
28005
28006   arg1 = (Dali::RenderTaskList *)jarg1;
28007   arg2 = (unsigned int)jarg2;
28008   {
28009     try {
28010       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
28011     } catch (std::out_of_range& e) {
28012       {
28013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28014       };
28015     } catch (std::exception& e) {
28016       {
28017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28018       };
28019     } catch (Dali::DaliException e) {
28020       {
28021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28022       };
28023     } catch (...) {
28024       {
28025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28026       };
28027     }
28028   }
28029
28030   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28031   return jresult;
28032 }
28033
28034
28035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
28036   int jresult ;
28037   int result;
28038
28039   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
28040   jresult = (int)result;
28041   return jresult;
28042 }
28043
28044
28045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
28046   int jresult ;
28047   int result;
28048
28049   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
28050   jresult = (int)result;
28051   return jresult;
28052 }
28053
28054
28055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28056   int jresult ;
28057   int result;
28058
28059   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28060   jresult = (int)result;
28061   return jresult;
28062 }
28063
28064
28065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28066   int jresult ;
28067   int result;
28068
28069   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28070   jresult = (int)result;
28071   return jresult;
28072 }
28073
28074
28075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28076   void * jresult ;
28077   Dali::RenderTask::Property *result = 0 ;
28078
28079   {
28080     try {
28081       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28082     } catch (std::out_of_range& e) {
28083       {
28084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28085       };
28086     } catch (std::exception& e) {
28087       {
28088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28089       };
28090     } catch (Dali::DaliException e) {
28091       {
28092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28093       };
28094     } catch (...) {
28095       {
28096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28097       };
28098     }
28099   }
28100
28101   jresult = (void *)result;
28102   return jresult;
28103 }
28104
28105
28106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28107   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28108
28109   arg1 = (Dali::RenderTask::Property *)jarg1;
28110   {
28111     try {
28112       delete arg1;
28113     } catch (std::out_of_range& e) {
28114       {
28115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28116       };
28117     } catch (std::exception& e) {
28118       {
28119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28120       };
28121     } catch (Dali::DaliException e) {
28122       {
28123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28124       };
28125     } catch (...) {
28126       {
28127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28128       };
28129     }
28130   }
28131
28132 }
28133
28134
28135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28136   void * jresult ;
28137   bool (*result)(Dali::Vector2 &) = 0 ;
28138
28139   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28140   jresult = (void *)result;
28141   return jresult;
28142 }
28143
28144
28145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28146   void * jresult ;
28147   bool (*result)(Dali::Vector2 &) = 0 ;
28148
28149   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28150   jresult = (void *)result;
28151   return jresult;
28152 }
28153
28154
28155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28156   unsigned int jresult ;
28157   bool result;
28158
28159   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28160   jresult = result;
28161   return jresult;
28162 }
28163
28164
28165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28166   unsigned int jresult ;
28167   bool result;
28168
28169   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28170   jresult = result;
28171   return jresult;
28172 }
28173
28174
28175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28176   void * jresult ;
28177   Dali::Vector4 *result = 0 ;
28178
28179   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28180   jresult = (void *)result;
28181   return jresult;
28182 }
28183
28184
28185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28186   unsigned int jresult ;
28187   bool result;
28188
28189   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28190   jresult = result;
28191   return jresult;
28192 }
28193
28194
28195 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28196   unsigned int jresult ;
28197   bool result;
28198
28199   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28200   jresult = result;
28201   return jresult;
28202 }
28203
28204
28205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28206   unsigned int jresult ;
28207   unsigned int result;
28208
28209   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28210   jresult = result;
28211   return jresult;
28212 }
28213
28214
28215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28216   void * jresult ;
28217   Dali::RenderTask *result = 0 ;
28218
28219   {
28220     try {
28221       result = (Dali::RenderTask *)new Dali::RenderTask();
28222     } catch (std::out_of_range& e) {
28223       {
28224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28225       };
28226     } catch (std::exception& e) {
28227       {
28228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28229       };
28230     } catch (Dali::DaliException e) {
28231       {
28232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28233       };
28234     } catch (...) {
28235       {
28236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28237       };
28238     }
28239   }
28240
28241   jresult = (void *)result;
28242   return jresult;
28243 }
28244
28245
28246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28247   void * jresult ;
28248   Dali::BaseHandle arg1 ;
28249   Dali::BaseHandle *argp1 ;
28250   Dali::RenderTask result;
28251
28252   argp1 = (Dali::BaseHandle *)jarg1;
28253   if (!argp1) {
28254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28255     return 0;
28256   }
28257   arg1 = *argp1;
28258   {
28259     try {
28260       result = Dali::RenderTask::DownCast(arg1);
28261     } catch (std::out_of_range& e) {
28262       {
28263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28264       };
28265     } catch (std::exception& e) {
28266       {
28267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28268       };
28269     } catch (Dali::DaliException e) {
28270       {
28271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28272       };
28273     } catch (...) {
28274       {
28275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28276       };
28277     }
28278   }
28279
28280   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28281   return jresult;
28282 }
28283
28284
28285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28286   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28287
28288   arg1 = (Dali::RenderTask *)jarg1;
28289   {
28290     try {
28291       delete arg1;
28292     } catch (std::out_of_range& e) {
28293       {
28294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28295       };
28296     } catch (std::exception& e) {
28297       {
28298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28299       };
28300     } catch (Dali::DaliException e) {
28301       {
28302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28303       };
28304     } catch (...) {
28305       {
28306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28307       };
28308     }
28309   }
28310
28311 }
28312
28313
28314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28315   void * jresult ;
28316   Dali::RenderTask *arg1 = 0 ;
28317   Dali::RenderTask *result = 0 ;
28318
28319   arg1 = (Dali::RenderTask *)jarg1;
28320   if (!arg1) {
28321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28322     return 0;
28323   }
28324   {
28325     try {
28326       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28327     } catch (std::out_of_range& e) {
28328       {
28329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28330       };
28331     } catch (std::exception& e) {
28332       {
28333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28334       };
28335     } catch (Dali::DaliException e) {
28336       {
28337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28338       };
28339     } catch (...) {
28340       {
28341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28342       };
28343     }
28344   }
28345
28346   jresult = (void *)result;
28347   return jresult;
28348 }
28349
28350
28351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28352   void * jresult ;
28353   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28354   Dali::RenderTask *arg2 = 0 ;
28355   Dali::RenderTask *result = 0 ;
28356
28357   arg1 = (Dali::RenderTask *)jarg1;
28358   arg2 = (Dali::RenderTask *)jarg2;
28359   if (!arg2) {
28360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28361     return 0;
28362   }
28363   {
28364     try {
28365       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28366     } catch (std::out_of_range& e) {
28367       {
28368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28369       };
28370     } catch (std::exception& e) {
28371       {
28372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28373       };
28374     } catch (Dali::DaliException e) {
28375       {
28376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28377       };
28378     } catch (...) {
28379       {
28380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28381       };
28382     }
28383   }
28384
28385   jresult = (void *)result;
28386   return jresult;
28387 }
28388
28389
28390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28391   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28392   Dali::Actor arg2 ;
28393   Dali::Actor *argp2 ;
28394
28395   arg1 = (Dali::RenderTask *)jarg1;
28396   argp2 = (Dali::Actor *)jarg2;
28397   if (!argp2) {
28398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28399     return ;
28400   }
28401   arg2 = *argp2;
28402   {
28403     try {
28404       (arg1)->SetSourceActor(arg2);
28405     } catch (std::out_of_range& e) {
28406       {
28407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28408       };
28409     } catch (std::exception& e) {
28410       {
28411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28412       };
28413     } catch (Dali::DaliException e) {
28414       {
28415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28416       };
28417     } catch (...) {
28418       {
28419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28420       };
28421     }
28422   }
28423
28424 }
28425
28426
28427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28428   void * jresult ;
28429   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28430   Dali::Actor result;
28431
28432   arg1 = (Dali::RenderTask *)jarg1;
28433   {
28434     try {
28435       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28436     } catch (std::out_of_range& e) {
28437       {
28438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28439       };
28440     } catch (std::exception& e) {
28441       {
28442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28443       };
28444     } catch (Dali::DaliException e) {
28445       {
28446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28447       };
28448     } catch (...) {
28449       {
28450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28451       };
28452     }
28453   }
28454
28455   jresult = new Dali::Actor((const Dali::Actor &)result);
28456   return jresult;
28457 }
28458
28459
28460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28461   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28462   bool arg2 ;
28463
28464   arg1 = (Dali::RenderTask *)jarg1;
28465   arg2 = jarg2 ? true : false;
28466   {
28467     try {
28468       (arg1)->SetExclusive(arg2);
28469     } catch (std::out_of_range& e) {
28470       {
28471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28472       };
28473     } catch (std::exception& e) {
28474       {
28475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28476       };
28477     } catch (Dali::DaliException e) {
28478       {
28479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28480       };
28481     } catch (...) {
28482       {
28483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28484       };
28485     }
28486   }
28487
28488 }
28489
28490
28491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28492   unsigned int jresult ;
28493   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28494   bool result;
28495
28496   arg1 = (Dali::RenderTask *)jarg1;
28497   {
28498     try {
28499       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28500     } catch (std::out_of_range& e) {
28501       {
28502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28503       };
28504     } catch (std::exception& e) {
28505       {
28506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28507       };
28508     } catch (Dali::DaliException e) {
28509       {
28510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28511       };
28512     } catch (...) {
28513       {
28514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28515       };
28516     }
28517   }
28518
28519   jresult = result;
28520   return jresult;
28521 }
28522
28523
28524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28525   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28526   bool arg2 ;
28527
28528   arg1 = (Dali::RenderTask *)jarg1;
28529   arg2 = jarg2 ? true : false;
28530   {
28531     try {
28532       (arg1)->SetInputEnabled(arg2);
28533     } catch (std::out_of_range& e) {
28534       {
28535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28536       };
28537     } catch (std::exception& e) {
28538       {
28539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28540       };
28541     } catch (Dali::DaliException e) {
28542       {
28543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28544       };
28545     } catch (...) {
28546       {
28547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28548       };
28549     }
28550   }
28551
28552 }
28553
28554
28555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28556   unsigned int jresult ;
28557   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28558   bool result;
28559
28560   arg1 = (Dali::RenderTask *)jarg1;
28561   {
28562     try {
28563       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28564     } catch (std::out_of_range& e) {
28565       {
28566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28567       };
28568     } catch (std::exception& e) {
28569       {
28570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28571       };
28572     } catch (Dali::DaliException e) {
28573       {
28574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28575       };
28576     } catch (...) {
28577       {
28578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28579       };
28580     }
28581   }
28582
28583   jresult = result;
28584   return jresult;
28585 }
28586
28587
28588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28589   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28590   Dali::CameraActor arg2 ;
28591   Dali::CameraActor *argp2 ;
28592
28593   arg1 = (Dali::RenderTask *)jarg1;
28594   argp2 = (Dali::CameraActor *)jarg2;
28595   if (!argp2) {
28596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28597     return ;
28598   }
28599   arg2 = *argp2;
28600   {
28601     try {
28602       (arg1)->SetCameraActor(arg2);
28603     } catch (std::out_of_range& e) {
28604       {
28605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28606       };
28607     } catch (std::exception& e) {
28608       {
28609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28610       };
28611     } catch (Dali::DaliException e) {
28612       {
28613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28614       };
28615     } catch (...) {
28616       {
28617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28618       };
28619     }
28620   }
28621
28622 }
28623
28624
28625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28626   void * jresult ;
28627   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28628   Dali::CameraActor result;
28629
28630   arg1 = (Dali::RenderTask *)jarg1;
28631   {
28632     try {
28633       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28634     } catch (std::out_of_range& e) {
28635       {
28636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28637       };
28638     } catch (std::exception& e) {
28639       {
28640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28641       };
28642     } catch (Dali::DaliException e) {
28643       {
28644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28645       };
28646     } catch (...) {
28647       {
28648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28649       };
28650     }
28651   }
28652
28653   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28654   return jresult;
28655 }
28656
28657
28658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28659   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28660   Dali::FrameBufferImage arg2 ;
28661   Dali::FrameBufferImage *argp2 ;
28662
28663   arg1 = (Dali::RenderTask *)jarg1;
28664   argp2 = (Dali::FrameBufferImage *)jarg2;
28665   if (!argp2) {
28666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28667     return ;
28668   }
28669   arg2 = *argp2;
28670   {
28671     try {
28672       (arg1)->SetTargetFrameBuffer(arg2);
28673     } catch (std::out_of_range& e) {
28674       {
28675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28676       };
28677     } catch (std::exception& e) {
28678       {
28679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28680       };
28681     } catch (Dali::DaliException e) {
28682       {
28683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28684       };
28685     } catch (...) {
28686       {
28687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28688       };
28689     }
28690   }
28691
28692 }
28693
28694
28695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28696   void * jresult ;
28697   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28698   Dali::FrameBufferImage result;
28699
28700   arg1 = (Dali::RenderTask *)jarg1;
28701   {
28702     try {
28703       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28704     } catch (std::out_of_range& e) {
28705       {
28706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28707       };
28708     } catch (std::exception& e) {
28709       {
28710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28711       };
28712     } catch (Dali::DaliException e) {
28713       {
28714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28715       };
28716     } catch (...) {
28717       {
28718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28719       };
28720     }
28721   }
28722
28723   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28724   return jresult;
28725 }
28726
28727
28728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28729   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28730   Dali::FrameBuffer arg2 ;
28731   Dali::FrameBuffer *argp2 ;
28732
28733   arg1 = (Dali::RenderTask *)jarg1;
28734   argp2 = (Dali::FrameBuffer *)jarg2;
28735   if (!argp2) {
28736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28737     return ;
28738   }
28739   arg2 = *argp2;
28740   {
28741     try {
28742       (arg1)->SetFrameBuffer(arg2);
28743     } catch (std::out_of_range& e) {
28744       {
28745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28746       };
28747     } catch (std::exception& e) {
28748       {
28749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28750       };
28751     } catch (Dali::DaliException e) {
28752       {
28753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28754       };
28755     } catch (...) {
28756       {
28757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28758       };
28759     }
28760   }
28761
28762 }
28763
28764
28765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28766   void * jresult ;
28767   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28768   Dali::FrameBuffer result;
28769
28770   arg1 = (Dali::RenderTask *)jarg1;
28771   {
28772     try {
28773       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28774     } catch (std::out_of_range& e) {
28775       {
28776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28777       };
28778     } catch (std::exception& e) {
28779       {
28780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28781       };
28782     } catch (Dali::DaliException e) {
28783       {
28784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28785       };
28786     } catch (...) {
28787       {
28788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28789       };
28790     }
28791   }
28792
28793   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28794   return jresult;
28795 }
28796
28797
28798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28799   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28800   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28801
28802   arg1 = (Dali::RenderTask *)jarg1;
28803   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28804   {
28805     try {
28806       (arg1)->SetScreenToFrameBufferFunction(arg2);
28807     } catch (std::out_of_range& e) {
28808       {
28809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28810       };
28811     } catch (std::exception& e) {
28812       {
28813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28814       };
28815     } catch (Dali::DaliException e) {
28816       {
28817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28818       };
28819     } catch (...) {
28820       {
28821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28822       };
28823     }
28824   }
28825
28826 }
28827
28828
28829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28830   void * jresult ;
28831   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28832   Dali::RenderTask::ScreenToFrameBufferFunction result;
28833
28834   arg1 = (Dali::RenderTask *)jarg1;
28835   {
28836     try {
28837       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28838     } catch (std::out_of_range& e) {
28839       {
28840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28841       };
28842     } catch (std::exception& e) {
28843       {
28844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28845       };
28846     } catch (Dali::DaliException e) {
28847       {
28848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28849       };
28850     } catch (...) {
28851       {
28852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28853       };
28854     }
28855   }
28856
28857   jresult = (void *)result;
28858   return jresult;
28859 }
28860
28861
28862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28863   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28864   Dali::Actor arg2 ;
28865   Dali::Actor *argp2 ;
28866
28867   arg1 = (Dali::RenderTask *)jarg1;
28868   argp2 = (Dali::Actor *)jarg2;
28869   if (!argp2) {
28870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28871     return ;
28872   }
28873   arg2 = *argp2;
28874   {
28875     try {
28876       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28877     } catch (std::out_of_range& e) {
28878       {
28879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28880       };
28881     } catch (std::exception& e) {
28882       {
28883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28884       };
28885     } catch (Dali::DaliException e) {
28886       {
28887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28888       };
28889     } catch (...) {
28890       {
28891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28892       };
28893     }
28894   }
28895
28896 }
28897
28898
28899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28900   void * jresult ;
28901   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28902   Dali::Actor result;
28903
28904   arg1 = (Dali::RenderTask *)jarg1;
28905   {
28906     try {
28907       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28908     } catch (std::out_of_range& e) {
28909       {
28910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28911       };
28912     } catch (std::exception& e) {
28913       {
28914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28915       };
28916     } catch (Dali::DaliException e) {
28917       {
28918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28919       };
28920     } catch (...) {
28921       {
28922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28923       };
28924     }
28925   }
28926
28927   jresult = new Dali::Actor((const Dali::Actor &)result);
28928   return jresult;
28929 }
28930
28931
28932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28933   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28934   Dali::Vector2 arg2 ;
28935   Dali::Vector2 *argp2 ;
28936
28937   arg1 = (Dali::RenderTask *)jarg1;
28938   argp2 = (Dali::Vector2 *)jarg2;
28939   if (!argp2) {
28940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28941     return ;
28942   }
28943   arg2 = *argp2;
28944   {
28945     try {
28946       (arg1)->SetViewportPosition(arg2);
28947     } catch (std::out_of_range& e) {
28948       {
28949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28950       };
28951     } catch (std::exception& e) {
28952       {
28953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28954       };
28955     } catch (Dali::DaliException e) {
28956       {
28957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28958       };
28959     } catch (...) {
28960       {
28961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28962       };
28963     }
28964   }
28965
28966 }
28967
28968
28969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28970   void * jresult ;
28971   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28972   Dali::Vector2 result;
28973
28974   arg1 = (Dali::RenderTask *)jarg1;
28975   {
28976     try {
28977       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28978     } catch (std::out_of_range& e) {
28979       {
28980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28981       };
28982     } catch (std::exception& e) {
28983       {
28984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28985       };
28986     } catch (Dali::DaliException e) {
28987       {
28988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28989       };
28990     } catch (...) {
28991       {
28992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28993       };
28994     }
28995   }
28996
28997   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28998   return jresult;
28999 }
29000
29001
29002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
29003   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29004   Dali::Vector2 arg2 ;
29005   Dali::Vector2 *argp2 ;
29006
29007   arg1 = (Dali::RenderTask *)jarg1;
29008   argp2 = (Dali::Vector2 *)jarg2;
29009   if (!argp2) {
29010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29011     return ;
29012   }
29013   arg2 = *argp2;
29014   {
29015     try {
29016       (arg1)->SetViewportSize(arg2);
29017     } catch (std::out_of_range& e) {
29018       {
29019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29020       };
29021     } catch (std::exception& e) {
29022       {
29023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29024       };
29025     } catch (Dali::DaliException e) {
29026       {
29027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29028       };
29029     } catch (...) {
29030       {
29031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29032       };
29033     }
29034   }
29035
29036 }
29037
29038
29039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
29040   void * jresult ;
29041   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29042   Dali::Vector2 result;
29043
29044   arg1 = (Dali::RenderTask *)jarg1;
29045   {
29046     try {
29047       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
29048     } catch (std::out_of_range& e) {
29049       {
29050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29051       };
29052     } catch (std::exception& e) {
29053       {
29054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29055       };
29056     } catch (Dali::DaliException e) {
29057       {
29058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29059       };
29060     } catch (...) {
29061       {
29062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29063       };
29064     }
29065   }
29066
29067   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29068   return jresult;
29069 }
29070
29071
29072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29073   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29074   Dali::Viewport arg2 ;
29075   Dali::Viewport *argp2 ;
29076
29077   arg1 = (Dali::RenderTask *)jarg1;
29078   argp2 = (Dali::Viewport *)jarg2;
29079   if (!argp2) {
29080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29081     return ;
29082   }
29083   arg2 = *argp2;
29084   {
29085     try {
29086       (arg1)->SetViewport(arg2);
29087     } catch (std::out_of_range& e) {
29088       {
29089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29090       };
29091     } catch (std::exception& e) {
29092       {
29093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29094       };
29095     } catch (Dali::DaliException e) {
29096       {
29097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29098       };
29099     } catch (...) {
29100       {
29101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29102       };
29103     }
29104   }
29105
29106 }
29107
29108
29109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29110   void * jresult ;
29111   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29112   Dali::Viewport result;
29113
29114   arg1 = (Dali::RenderTask *)jarg1;
29115   {
29116     try {
29117       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29118     } catch (std::out_of_range& e) {
29119       {
29120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29121       };
29122     } catch (std::exception& e) {
29123       {
29124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29125       };
29126     } catch (Dali::DaliException e) {
29127       {
29128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29129       };
29130     } catch (...) {
29131       {
29132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29133       };
29134     }
29135   }
29136
29137   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29138   return jresult;
29139 }
29140
29141
29142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29143   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29144   Dali::Vector4 *arg2 = 0 ;
29145
29146   arg1 = (Dali::RenderTask *)jarg1;
29147   arg2 = (Dali::Vector4 *)jarg2;
29148   if (!arg2) {
29149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29150     return ;
29151   }
29152   {
29153     try {
29154       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29155     } catch (std::out_of_range& e) {
29156       {
29157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29158       };
29159     } catch (std::exception& e) {
29160       {
29161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29162       };
29163     } catch (Dali::DaliException e) {
29164       {
29165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29166       };
29167     } catch (...) {
29168       {
29169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29170       };
29171     }
29172   }
29173
29174 }
29175
29176
29177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29178   void * jresult ;
29179   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29180   Dali::Vector4 result;
29181
29182   arg1 = (Dali::RenderTask *)jarg1;
29183   {
29184     try {
29185       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29186     } catch (std::out_of_range& e) {
29187       {
29188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29189       };
29190     } catch (std::exception& e) {
29191       {
29192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29193       };
29194     } catch (Dali::DaliException e) {
29195       {
29196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29197       };
29198     } catch (...) {
29199       {
29200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29201       };
29202     }
29203   }
29204
29205   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29206   return jresult;
29207 }
29208
29209
29210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29211   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29212   bool arg2 ;
29213
29214   arg1 = (Dali::RenderTask *)jarg1;
29215   arg2 = jarg2 ? true : false;
29216   {
29217     try {
29218       (arg1)->SetClearEnabled(arg2);
29219     } catch (std::out_of_range& e) {
29220       {
29221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29222       };
29223     } catch (std::exception& e) {
29224       {
29225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29226       };
29227     } catch (Dali::DaliException e) {
29228       {
29229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29230       };
29231     } catch (...) {
29232       {
29233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29234       };
29235     }
29236   }
29237
29238 }
29239
29240
29241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29242   unsigned int jresult ;
29243   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29244   bool result;
29245
29246   arg1 = (Dali::RenderTask *)jarg1;
29247   {
29248     try {
29249       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29250     } catch (std::out_of_range& e) {
29251       {
29252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29253       };
29254     } catch (std::exception& e) {
29255       {
29256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29257       };
29258     } catch (Dali::DaliException e) {
29259       {
29260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29261       };
29262     } catch (...) {
29263       {
29264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29265       };
29266     }
29267   }
29268
29269   jresult = result;
29270   return jresult;
29271 }
29272
29273
29274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29275   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29276   bool arg2 ;
29277
29278   arg1 = (Dali::RenderTask *)jarg1;
29279   arg2 = jarg2 ? true : false;
29280   {
29281     try {
29282       (arg1)->SetCullMode(arg2);
29283     } catch (std::out_of_range& e) {
29284       {
29285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29286       };
29287     } catch (std::exception& e) {
29288       {
29289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29290       };
29291     } catch (Dali::DaliException e) {
29292       {
29293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29294       };
29295     } catch (...) {
29296       {
29297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29298       };
29299     }
29300   }
29301
29302 }
29303
29304
29305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29306   unsigned int jresult ;
29307   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29308   bool result;
29309
29310   arg1 = (Dali::RenderTask *)jarg1;
29311   {
29312     try {
29313       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29314     } catch (std::out_of_range& e) {
29315       {
29316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29317       };
29318     } catch (std::exception& e) {
29319       {
29320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29321       };
29322     } catch (Dali::DaliException e) {
29323       {
29324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29325       };
29326     } catch (...) {
29327       {
29328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29329       };
29330     }
29331   }
29332
29333   jresult = result;
29334   return jresult;
29335 }
29336
29337
29338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29339   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29340   unsigned int arg2 ;
29341
29342   arg1 = (Dali::RenderTask *)jarg1;
29343   arg2 = (unsigned int)jarg2;
29344   {
29345     try {
29346       (arg1)->SetRefreshRate(arg2);
29347     } catch (std::out_of_range& e) {
29348       {
29349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29350       };
29351     } catch (std::exception& e) {
29352       {
29353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29354       };
29355     } catch (Dali::DaliException e) {
29356       {
29357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29358       };
29359     } catch (...) {
29360       {
29361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29362       };
29363     }
29364   }
29365
29366 }
29367
29368
29369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29370   unsigned int jresult ;
29371   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29372   unsigned int result;
29373
29374   arg1 = (Dali::RenderTask *)jarg1;
29375   {
29376     try {
29377       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29378     } catch (std::out_of_range& e) {
29379       {
29380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29381       };
29382     } catch (std::exception& e) {
29383       {
29384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29385       };
29386     } catch (Dali::DaliException e) {
29387       {
29388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29389       };
29390     } catch (...) {
29391       {
29392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29393       };
29394     }
29395   }
29396
29397   jresult = result;
29398   return jresult;
29399 }
29400
29401
29402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29403   unsigned int jresult ;
29404   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29405   Dali::Vector3 *arg2 = 0 ;
29406   float *arg3 = 0 ;
29407   float *arg4 = 0 ;
29408   bool result;
29409
29410   arg1 = (Dali::RenderTask *)jarg1;
29411   arg2 = (Dali::Vector3 *)jarg2;
29412   if (!arg2) {
29413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29414     return 0;
29415   }
29416   arg3 = (float *)jarg3;
29417   arg4 = (float *)jarg4;
29418   {
29419     try {
29420       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29421     } catch (std::out_of_range& e) {
29422       {
29423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29424       };
29425     } catch (std::exception& e) {
29426       {
29427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29428       };
29429     } catch (Dali::DaliException e) {
29430       {
29431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29432       };
29433     } catch (...) {
29434       {
29435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29436       };
29437     }
29438   }
29439
29440   jresult = result;
29441   return jresult;
29442 }
29443
29444
29445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29446   unsigned int jresult ;
29447   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29448   Dali::Actor arg2 ;
29449   float arg3 ;
29450   float arg4 ;
29451   float *arg5 = 0 ;
29452   float *arg6 = 0 ;
29453   Dali::Actor *argp2 ;
29454   bool result;
29455
29456   arg1 = (Dali::RenderTask *)jarg1;
29457   argp2 = (Dali::Actor *)jarg2;
29458   if (!argp2) {
29459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29460     return 0;
29461   }
29462   arg2 = *argp2;
29463   arg3 = (float)jarg3;
29464   arg4 = (float)jarg4;
29465   arg5 = (float *)jarg5;
29466   arg6 = (float *)jarg6;
29467   {
29468     try {
29469       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29470     } catch (std::out_of_range& e) {
29471       {
29472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29473       };
29474     } catch (std::exception& e) {
29475       {
29476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29477       };
29478     } catch (Dali::DaliException e) {
29479       {
29480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29481       };
29482     } catch (...) {
29483       {
29484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29485       };
29486     }
29487   }
29488
29489   jresult = result;
29490   return jresult;
29491 }
29492
29493
29494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29495   void * jresult ;
29496   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29497   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29498
29499   arg1 = (Dali::RenderTask *)jarg1;
29500   {
29501     try {
29502       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29503     } catch (std::out_of_range& e) {
29504       {
29505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29506       };
29507     } catch (std::exception& e) {
29508       {
29509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29510       };
29511     } catch (Dali::DaliException e) {
29512       {
29513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29514       };
29515     } catch (...) {
29516       {
29517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29518       };
29519     }
29520   }
29521
29522   jresult = (void *)result;
29523   return jresult;
29524 }
29525
29526
29527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29528   void * jresult ;
29529   int arg1 ;
29530   Dali::TouchPoint::State arg2 ;
29531   float arg3 ;
29532   float arg4 ;
29533   Dali::TouchPoint *result = 0 ;
29534
29535   arg1 = (int)jarg1;
29536   arg2 = (Dali::TouchPoint::State)jarg2;
29537   arg3 = (float)jarg3;
29538   arg4 = (float)jarg4;
29539   {
29540     try {
29541       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29542     } catch (std::out_of_range& e) {
29543       {
29544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29545       };
29546     } catch (std::exception& e) {
29547       {
29548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29549       };
29550     } catch (Dali::DaliException e) {
29551       {
29552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29553       };
29554     } catch (...) {
29555       {
29556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29557       };
29558     }
29559   }
29560
29561   jresult = (void *)result;
29562   return jresult;
29563 }
29564
29565
29566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29567   void * jresult ;
29568   int arg1 ;
29569   Dali::TouchPoint::State arg2 ;
29570   float arg3 ;
29571   float arg4 ;
29572   float arg5 ;
29573   float arg6 ;
29574   Dali::TouchPoint *result = 0 ;
29575
29576   arg1 = (int)jarg1;
29577   arg2 = (Dali::TouchPoint::State)jarg2;
29578   arg3 = (float)jarg3;
29579   arg4 = (float)jarg4;
29580   arg5 = (float)jarg5;
29581   arg6 = (float)jarg6;
29582   {
29583     try {
29584       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29585     } catch (std::out_of_range& e) {
29586       {
29587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29588       };
29589     } catch (std::exception& e) {
29590       {
29591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29592       };
29593     } catch (Dali::DaliException e) {
29594       {
29595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29596       };
29597     } catch (...) {
29598       {
29599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29600       };
29601     }
29602   }
29603
29604   jresult = (void *)result;
29605   return jresult;
29606 }
29607
29608
29609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29610   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29611
29612   arg1 = (Dali::TouchPoint *)jarg1;
29613   {
29614     try {
29615       delete arg1;
29616     } catch (std::out_of_range& e) {
29617       {
29618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29619       };
29620     } catch (std::exception& e) {
29621       {
29622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29623       };
29624     } catch (Dali::DaliException e) {
29625       {
29626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29627       };
29628     } catch (...) {
29629       {
29630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29631       };
29632     }
29633   }
29634
29635 }
29636
29637
29638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29639   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29640   int arg2 ;
29641
29642   arg1 = (Dali::TouchPoint *)jarg1;
29643   arg2 = (int)jarg2;
29644   if (arg1) (arg1)->deviceId = arg2;
29645 }
29646
29647
29648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29649   int jresult ;
29650   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29651   int result;
29652
29653   arg1 = (Dali::TouchPoint *)jarg1;
29654   result = (int) ((arg1)->deviceId);
29655   jresult = result;
29656   return jresult;
29657 }
29658
29659
29660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29661   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29662   Dali::TouchPoint::State arg2 ;
29663
29664   arg1 = (Dali::TouchPoint *)jarg1;
29665   arg2 = (Dali::TouchPoint::State)jarg2;
29666   if (arg1) (arg1)->state = arg2;
29667 }
29668
29669
29670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29671   int jresult ;
29672   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29673   Dali::TouchPoint::State result;
29674
29675   arg1 = (Dali::TouchPoint *)jarg1;
29676   result = (Dali::TouchPoint::State) ((arg1)->state);
29677   jresult = (int)result;
29678   return jresult;
29679 }
29680
29681
29682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29683   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29684   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29685
29686   arg1 = (Dali::TouchPoint *)jarg1;
29687   arg2 = (Dali::Actor *)jarg2;
29688   if (arg1) (arg1)->hitActor = *arg2;
29689 }
29690
29691
29692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29693   void * jresult ;
29694   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29695   Dali::Actor *result = 0 ;
29696
29697   arg1 = (Dali::TouchPoint *)jarg1;
29698   result = (Dali::Actor *)& ((arg1)->hitActor);
29699   jresult = (void *)result;
29700   return jresult;
29701 }
29702
29703
29704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29705   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29706   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29707
29708   arg1 = (Dali::TouchPoint *)jarg1;
29709   arg2 = (Dali::Vector2 *)jarg2;
29710   if (arg1) (arg1)->local = *arg2;
29711 }
29712
29713
29714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29715   void * jresult ;
29716   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29717   Dali::Vector2 *result = 0 ;
29718
29719   arg1 = (Dali::TouchPoint *)jarg1;
29720   result = (Dali::Vector2 *)& ((arg1)->local);
29721   jresult = (void *)result;
29722   return jresult;
29723 }
29724
29725
29726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29727   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29728   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29729
29730   arg1 = (Dali::TouchPoint *)jarg1;
29731   arg2 = (Dali::Vector2 *)jarg2;
29732   if (arg1) (arg1)->screen = *arg2;
29733 }
29734
29735
29736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29737   void * jresult ;
29738   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29739   Dali::Vector2 *result = 0 ;
29740
29741   arg1 = (Dali::TouchPoint *)jarg1;
29742   result = (Dali::Vector2 *)& ((arg1)->screen);
29743   jresult = (void *)result;
29744   return jresult;
29745 }
29746
29747
29748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29749   void * jresult ;
29750   Dali::TouchData *result = 0 ;
29751
29752   {
29753     try {
29754       result = (Dali::TouchData *)new Dali::TouchData();
29755     } catch (std::out_of_range& e) {
29756       {
29757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29758       };
29759     } catch (std::exception& e) {
29760       {
29761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29762       };
29763     } catch (Dali::DaliException e) {
29764       {
29765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29766       };
29767     } catch (...) {
29768       {
29769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29770       };
29771     }
29772   }
29773
29774   jresult = (void *)result;
29775   return jresult;
29776 }
29777
29778
29779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29780   void * jresult ;
29781   Dali::TouchData *arg1 = 0 ;
29782   Dali::TouchData *result = 0 ;
29783
29784   arg1 = (Dali::TouchData *)jarg1;
29785   if (!arg1) {
29786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29787     return 0;
29788   }
29789   {
29790     try {
29791       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29792     } catch (std::out_of_range& e) {
29793       {
29794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29795       };
29796     } catch (std::exception& e) {
29797       {
29798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29799       };
29800     } catch (Dali::DaliException e) {
29801       {
29802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29803       };
29804     } catch (...) {
29805       {
29806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29807       };
29808     }
29809   }
29810
29811   jresult = (void *)result;
29812   return jresult;
29813 }
29814
29815
29816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29817   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29818
29819   arg1 = (Dali::TouchData *)jarg1;
29820   {
29821     try {
29822       delete arg1;
29823     } catch (std::out_of_range& e) {
29824       {
29825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29826       };
29827     } catch (std::exception& e) {
29828       {
29829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29830       };
29831     } catch (Dali::DaliException e) {
29832       {
29833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29834       };
29835     } catch (...) {
29836       {
29837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29838       };
29839     }
29840   }
29841
29842 }
29843
29844
29845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29846   void * jresult ;
29847   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29848   Dali::TouchData *arg2 = 0 ;
29849   Dali::TouchData *result = 0 ;
29850
29851   arg1 = (Dali::TouchData *)jarg1;
29852   arg2 = (Dali::TouchData *)jarg2;
29853   if (!arg2) {
29854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29855     return 0;
29856   }
29857   {
29858     try {
29859       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29860     } catch (std::out_of_range& e) {
29861       {
29862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29863       };
29864     } catch (std::exception& e) {
29865       {
29866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29867       };
29868     } catch (Dali::DaliException e) {
29869       {
29870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29871       };
29872     } catch (...) {
29873       {
29874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29875       };
29876     }
29877   }
29878
29879   jresult = (void *)result;
29880   return jresult;
29881 }
29882
29883
29884 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29885   unsigned long jresult ;
29886   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29887   unsigned long result;
29888
29889   arg1 = (Dali::TouchData *)jarg1;
29890   {
29891     try {
29892       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29893     } catch (std::out_of_range& e) {
29894       {
29895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29896       };
29897     } catch (std::exception& e) {
29898       {
29899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29900       };
29901     } catch (Dali::DaliException e) {
29902       {
29903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29904       };
29905     } catch (...) {
29906       {
29907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29908       };
29909     }
29910   }
29911
29912   jresult = (unsigned long)result;
29913   return jresult;
29914 }
29915
29916
29917 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29918   unsigned long jresult ;
29919   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29920   std::size_t result;
29921
29922   arg1 = (Dali::TouchData *)jarg1;
29923   {
29924     try {
29925       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29926     } catch (std::out_of_range& e) {
29927       {
29928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29929       };
29930     } catch (std::exception& e) {
29931       {
29932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29933       };
29934     } catch (Dali::DaliException e) {
29935       {
29936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29937       };
29938     } catch (...) {
29939       {
29940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29941       };
29942     }
29943   }
29944
29945   jresult = (unsigned long)result;
29946   return jresult;
29947 }
29948
29949
29950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29951   int jresult ;
29952   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29953   std::size_t arg2 ;
29954   int32_t result;
29955
29956   arg1 = (Dali::TouchData *)jarg1;
29957   arg2 = (std::size_t)jarg2;
29958   {
29959     try {
29960       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29961     } catch (std::out_of_range& e) {
29962       {
29963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29964       };
29965     } catch (std::exception& e) {
29966       {
29967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29968       };
29969     } catch (Dali::DaliException e) {
29970       {
29971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29972       };
29973     } catch (...) {
29974       {
29975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29976       };
29977     }
29978   }
29979
29980   jresult = result;
29981   return jresult;
29982 }
29983
29984
29985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29986   int jresult ;
29987   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29988   std::size_t arg2 ;
29989   Dali::PointState::Type result;
29990
29991   arg1 = (Dali::TouchData *)jarg1;
29992   arg2 = (std::size_t)jarg2;
29993   {
29994     try {
29995       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29996     } catch (std::out_of_range& e) {
29997       {
29998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29999       };
30000     } catch (std::exception& e) {
30001       {
30002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30003       };
30004     } catch (Dali::DaliException e) {
30005       {
30006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30007       };
30008     } catch (...) {
30009       {
30010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30011       };
30012     }
30013   }
30014
30015   jresult = (int)result;
30016   return jresult;
30017 }
30018
30019
30020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
30021   void * jresult ;
30022   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30023   std::size_t arg2 ;
30024   Dali::Actor result;
30025
30026   arg1 = (Dali::TouchData *)jarg1;
30027   arg2 = (std::size_t)jarg2;
30028   {
30029     try {
30030       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
30031     } catch (std::out_of_range& e) {
30032       {
30033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30034       };
30035     } catch (std::exception& e) {
30036       {
30037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30038       };
30039     } catch (Dali::DaliException e) {
30040       {
30041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30042       };
30043     } catch (...) {
30044       {
30045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30046       };
30047     }
30048   }
30049
30050   jresult = new Dali::Actor((const Dali::Actor &)result);
30051   return jresult;
30052 }
30053
30054
30055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30056   void * jresult ;
30057   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30058   std::size_t arg2 ;
30059   Dali::Vector2 *result = 0 ;
30060
30061   arg1 = (Dali::TouchData *)jarg1;
30062   arg2 = (std::size_t)jarg2;
30063   {
30064     try {
30065       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30066     } catch (std::out_of_range& e) {
30067       {
30068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30069       };
30070     } catch (std::exception& e) {
30071       {
30072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30073       };
30074     } catch (Dali::DaliException e) {
30075       {
30076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30077       };
30078     } catch (...) {
30079       {
30080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30081       };
30082     }
30083   }
30084
30085   jresult = (void *)result;
30086   return jresult;
30087 }
30088
30089
30090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30091   void * jresult ;
30092   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30093   std::size_t arg2 ;
30094   Dali::Vector2 *result = 0 ;
30095
30096   arg1 = (Dali::TouchData *)jarg1;
30097   arg2 = (std::size_t)jarg2;
30098   {
30099     try {
30100       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30101     } catch (std::out_of_range& e) {
30102       {
30103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30104       };
30105     } catch (std::exception& e) {
30106       {
30107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30108       };
30109     } catch (Dali::DaliException e) {
30110       {
30111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30112       };
30113     } catch (...) {
30114       {
30115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30116       };
30117     }
30118   }
30119
30120   jresult = (void *)result;
30121   return jresult;
30122 }
30123
30124
30125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30126   float jresult ;
30127   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30128   std::size_t arg2 ;
30129   float result;
30130
30131   arg1 = (Dali::TouchData *)jarg1;
30132   arg2 = (std::size_t)jarg2;
30133   {
30134     try {
30135       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30136     } catch (std::out_of_range& e) {
30137       {
30138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30139       };
30140     } catch (std::exception& e) {
30141       {
30142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30143       };
30144     } catch (Dali::DaliException e) {
30145       {
30146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30147       };
30148     } catch (...) {
30149       {
30150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30151       };
30152     }
30153   }
30154
30155   jresult = result;
30156   return jresult;
30157 }
30158
30159
30160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30161   void * jresult ;
30162   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30163   std::size_t arg2 ;
30164   Dali::Vector2 *result = 0 ;
30165
30166   arg1 = (Dali::TouchData *)jarg1;
30167   arg2 = (std::size_t)jarg2;
30168   {
30169     try {
30170       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30171     } catch (std::out_of_range& e) {
30172       {
30173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30174       };
30175     } catch (std::exception& e) {
30176       {
30177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30178       };
30179     } catch (Dali::DaliException e) {
30180       {
30181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30182       };
30183     } catch (...) {
30184       {
30185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30186       };
30187     }
30188   }
30189
30190   jresult = (void *)result;
30191   return jresult;
30192 }
30193
30194
30195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30196   float jresult ;
30197   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30198   std::size_t arg2 ;
30199   float result;
30200
30201   arg1 = (Dali::TouchData *)jarg1;
30202   arg2 = (std::size_t)jarg2;
30203   {
30204     try {
30205       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30206     } catch (std::out_of_range& e) {
30207       {
30208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30209       };
30210     } catch (std::exception& e) {
30211       {
30212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30213       };
30214     } catch (Dali::DaliException e) {
30215       {
30216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30217       };
30218     } catch (...) {
30219       {
30220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30221       };
30222     }
30223   }
30224
30225   jresult = result;
30226   return jresult;
30227 }
30228
30229
30230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30231   void * jresult ;
30232   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30233   std::size_t arg2 ;
30234   Dali::Degree result;
30235
30236   arg1 = (Dali::TouchData *)jarg1;
30237   arg2 = (std::size_t)jarg2;
30238   {
30239     try {
30240       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30241     } catch (std::out_of_range& e) {
30242       {
30243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30244       };
30245     } catch (std::exception& e) {
30246       {
30247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30248       };
30249     } catch (Dali::DaliException e) {
30250       {
30251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30252       };
30253     } catch (...) {
30254       {
30255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30256       };
30257     }
30258   }
30259
30260   jresult = new Dali::Degree((const Dali::Degree &)result);
30261   return jresult;
30262 }
30263
30264
30265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30266   int jresult ;
30267   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30268   std::size_t arg2 ;
30269   Dali::MouseButton::Type result;
30270
30271   arg1 = (Dali::TouchData *)jarg1;
30272   arg2 = (std::size_t)jarg2;
30273   {
30274     try {
30275       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30276     } catch (std::out_of_range& e) {
30277       {
30278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30279       };
30280     } catch (std::exception& e) {
30281       {
30282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30283       };
30284     } catch (Dali::DaliException e) {
30285       {
30286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30287       };
30288     } catch (...) {
30289       {
30290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30291       };
30292     }
30293   }
30294
30295   jresult = static_cast< int >(result);
30296   return jresult;
30297 }
30298
30299
30300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30301   void * jresult ;
30302   Dali::GestureDetector *result = 0 ;
30303
30304   {
30305     try {
30306       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30307     } catch (std::out_of_range& e) {
30308       {
30309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30310       };
30311     } catch (std::exception& e) {
30312       {
30313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30314       };
30315     } catch (Dali::DaliException e) {
30316       {
30317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30318       };
30319     } catch (...) {
30320       {
30321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30322       };
30323     }
30324   }
30325
30326   jresult = (void *)result;
30327   return jresult;
30328 }
30329
30330
30331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30332   void * jresult ;
30333   Dali::BaseHandle arg1 ;
30334   Dali::BaseHandle *argp1 ;
30335   Dali::GestureDetector result;
30336
30337   argp1 = (Dali::BaseHandle *)jarg1;
30338   if (!argp1) {
30339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30340     return 0;
30341   }
30342   arg1 = *argp1;
30343   {
30344     try {
30345       result = Dali::GestureDetector::DownCast(arg1);
30346     } catch (std::out_of_range& e) {
30347       {
30348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30349       };
30350     } catch (std::exception& e) {
30351       {
30352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30353       };
30354     } catch (Dali::DaliException e) {
30355       {
30356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30357       };
30358     } catch (...) {
30359       {
30360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30361       };
30362     }
30363   }
30364
30365   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30366   return jresult;
30367 }
30368
30369
30370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30371   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30372
30373   arg1 = (Dali::GestureDetector *)jarg1;
30374   {
30375     try {
30376       delete arg1;
30377     } catch (std::out_of_range& e) {
30378       {
30379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30380       };
30381     } catch (std::exception& e) {
30382       {
30383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30384       };
30385     } catch (Dali::DaliException e) {
30386       {
30387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30388       };
30389     } catch (...) {
30390       {
30391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30392       };
30393     }
30394   }
30395
30396 }
30397
30398
30399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30400   void * jresult ;
30401   Dali::GestureDetector *arg1 = 0 ;
30402   Dali::GestureDetector *result = 0 ;
30403
30404   arg1 = (Dali::GestureDetector *)jarg1;
30405   if (!arg1) {
30406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30407     return 0;
30408   }
30409   {
30410     try {
30411       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30412     } catch (std::out_of_range& e) {
30413       {
30414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30415       };
30416     } catch (std::exception& e) {
30417       {
30418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30419       };
30420     } catch (Dali::DaliException e) {
30421       {
30422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30423       };
30424     } catch (...) {
30425       {
30426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30427       };
30428     }
30429   }
30430
30431   jresult = (void *)result;
30432   return jresult;
30433 }
30434
30435
30436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30437   void * jresult ;
30438   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30439   Dali::GestureDetector *arg2 = 0 ;
30440   Dali::GestureDetector *result = 0 ;
30441
30442   arg1 = (Dali::GestureDetector *)jarg1;
30443   arg2 = (Dali::GestureDetector *)jarg2;
30444   if (!arg2) {
30445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30446     return 0;
30447   }
30448   {
30449     try {
30450       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30451     } catch (std::out_of_range& e) {
30452       {
30453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30454       };
30455     } catch (std::exception& e) {
30456       {
30457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30458       };
30459     } catch (Dali::DaliException e) {
30460       {
30461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30462       };
30463     } catch (...) {
30464       {
30465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30466       };
30467     }
30468   }
30469
30470   jresult = (void *)result;
30471   return jresult;
30472 }
30473
30474
30475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30476   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30477   Dali::Actor arg2 ;
30478   Dali::Actor *argp2 ;
30479
30480   arg1 = (Dali::GestureDetector *)jarg1;
30481   argp2 = (Dali::Actor *)jarg2;
30482   if (!argp2) {
30483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30484     return ;
30485   }
30486   arg2 = *argp2;
30487   {
30488     try {
30489       (arg1)->Attach(arg2);
30490     } catch (std::out_of_range& e) {
30491       {
30492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30493       };
30494     } catch (std::exception& e) {
30495       {
30496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30497       };
30498     } catch (Dali::DaliException e) {
30499       {
30500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30501       };
30502     } catch (...) {
30503       {
30504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30505       };
30506     }
30507   }
30508
30509 }
30510
30511
30512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30513   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30514   Dali::Actor arg2 ;
30515   Dali::Actor *argp2 ;
30516
30517   arg1 = (Dali::GestureDetector *)jarg1;
30518   argp2 = (Dali::Actor *)jarg2;
30519   if (!argp2) {
30520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30521     return ;
30522   }
30523   arg2 = *argp2;
30524   {
30525     try {
30526       (arg1)->Detach(arg2);
30527     } catch (std::out_of_range& e) {
30528       {
30529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30530       };
30531     } catch (std::exception& e) {
30532       {
30533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30534       };
30535     } catch (Dali::DaliException e) {
30536       {
30537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30538       };
30539     } catch (...) {
30540       {
30541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30542       };
30543     }
30544   }
30545
30546 }
30547
30548
30549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30550   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30551
30552   arg1 = (Dali::GestureDetector *)jarg1;
30553   {
30554     try {
30555       (arg1)->DetachAll();
30556     } catch (std::out_of_range& e) {
30557       {
30558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30559       };
30560     } catch (std::exception& e) {
30561       {
30562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30563       };
30564     } catch (Dali::DaliException e) {
30565       {
30566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30567       };
30568     } catch (...) {
30569       {
30570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30571       };
30572     }
30573   }
30574
30575 }
30576
30577
30578 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30579   unsigned long jresult ;
30580   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30581   size_t result;
30582
30583   arg1 = (Dali::GestureDetector *)jarg1;
30584   {
30585     try {
30586       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30587     } catch (std::out_of_range& e) {
30588       {
30589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30590       };
30591     } catch (std::exception& e) {
30592       {
30593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30594       };
30595     } catch (Dali::DaliException e) {
30596       {
30597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30598       };
30599     } catch (...) {
30600       {
30601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30602       };
30603     }
30604   }
30605
30606   jresult = (unsigned long)result;
30607   return jresult;
30608 }
30609
30610
30611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30612   void * jresult ;
30613   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30614   size_t arg2 ;
30615   Dali::Actor result;
30616
30617   arg1 = (Dali::GestureDetector *)jarg1;
30618   arg2 = (size_t)jarg2;
30619   {
30620     try {
30621       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30622     } catch (std::out_of_range& e) {
30623       {
30624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30625       };
30626     } catch (std::exception& e) {
30627       {
30628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30629       };
30630     } catch (Dali::DaliException e) {
30631       {
30632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30633       };
30634     } catch (...) {
30635       {
30636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30637       };
30638     }
30639   }
30640
30641   jresult = new Dali::Actor((const Dali::Actor &)result);
30642   return jresult;
30643 }
30644
30645
30646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30647   void * jresult ;
30648   Dali::Gesture *arg1 = 0 ;
30649   Dali::Gesture *result = 0 ;
30650
30651   arg1 = (Dali::Gesture *)jarg1;
30652   if (!arg1) {
30653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30654     return 0;
30655   }
30656   {
30657     try {
30658       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30659     } catch (std::out_of_range& e) {
30660       {
30661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30662       };
30663     } catch (std::exception& e) {
30664       {
30665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30666       };
30667     } catch (Dali::DaliException e) {
30668       {
30669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30670       };
30671     } catch (...) {
30672       {
30673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30674       };
30675     }
30676   }
30677
30678   jresult = (void *)result;
30679   return jresult;
30680 }
30681
30682
30683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30684   void * jresult ;
30685   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30686   Dali::Gesture *arg2 = 0 ;
30687   Dali::Gesture *result = 0 ;
30688
30689   arg1 = (Dali::Gesture *)jarg1;
30690   arg2 = (Dali::Gesture *)jarg2;
30691   if (!arg2) {
30692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30693     return 0;
30694   }
30695   {
30696     try {
30697       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30698     } catch (std::out_of_range& e) {
30699       {
30700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30701       };
30702     } catch (std::exception& e) {
30703       {
30704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30705       };
30706     } catch (Dali::DaliException e) {
30707       {
30708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30709       };
30710     } catch (...) {
30711       {
30712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30713       };
30714     }
30715   }
30716
30717   jresult = (void *)result;
30718   return jresult;
30719 }
30720
30721
30722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30723   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30724
30725   arg1 = (Dali::Gesture *)jarg1;
30726   {
30727     try {
30728       delete arg1;
30729     } catch (std::out_of_range& e) {
30730       {
30731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30732       };
30733     } catch (std::exception& e) {
30734       {
30735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30736       };
30737     } catch (Dali::DaliException e) {
30738       {
30739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30740       };
30741     } catch (...) {
30742       {
30743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30744       };
30745     }
30746   }
30747
30748 }
30749
30750
30751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30752   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30753   Dali::Gesture::Type arg2 ;
30754
30755   arg1 = (Dali::Gesture *)jarg1;
30756   arg2 = (Dali::Gesture::Type)jarg2;
30757   if (arg1) (arg1)->type = arg2;
30758 }
30759
30760
30761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30762   int jresult ;
30763   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30764   Dali::Gesture::Type result;
30765
30766   arg1 = (Dali::Gesture *)jarg1;
30767   result = (Dali::Gesture::Type) ((arg1)->type);
30768   jresult = (int)result;
30769   return jresult;
30770 }
30771
30772
30773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30774   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30775   Dali::Gesture::State arg2 ;
30776
30777   arg1 = (Dali::Gesture *)jarg1;
30778   arg2 = (Dali::Gesture::State)jarg2;
30779   if (arg1) (arg1)->state = arg2;
30780 }
30781
30782
30783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30784   int jresult ;
30785   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30786   Dali::Gesture::State result;
30787
30788   arg1 = (Dali::Gesture *)jarg1;
30789   result = (Dali::Gesture::State) ((arg1)->state);
30790   jresult = (int)result;
30791   return jresult;
30792 }
30793
30794
30795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30796   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30797   unsigned int arg2 ;
30798
30799   arg1 = (Dali::Gesture *)jarg1;
30800   arg2 = (unsigned int)jarg2;
30801   if (arg1) (arg1)->time = arg2;
30802 }
30803
30804
30805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30806   unsigned int jresult ;
30807   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30808   unsigned int result;
30809
30810   arg1 = (Dali::Gesture *)jarg1;
30811   result = (unsigned int) ((arg1)->time);
30812   jresult = result;
30813   return jresult;
30814 }
30815
30816
30817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30818   void * jresult ;
30819   Dali::HoverEvent *result = 0 ;
30820
30821   {
30822     try {
30823       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30824     } catch (std::out_of_range& e) {
30825       {
30826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30827       };
30828     } catch (std::exception& e) {
30829       {
30830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30831       };
30832     } catch (Dali::DaliException e) {
30833       {
30834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30835       };
30836     } catch (...) {
30837       {
30838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30839       };
30840     }
30841   }
30842
30843   jresult = (void *)result;
30844   return jresult;
30845 }
30846
30847
30848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30849   void * jresult ;
30850   unsigned long arg1 ;
30851   Dali::HoverEvent *result = 0 ;
30852
30853   arg1 = (unsigned long)jarg1;
30854   {
30855     try {
30856       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30857     } catch (std::out_of_range& e) {
30858       {
30859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30860       };
30861     } catch (std::exception& e) {
30862       {
30863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30864       };
30865     } catch (Dali::DaliException e) {
30866       {
30867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30868       };
30869     } catch (...) {
30870       {
30871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30872       };
30873     }
30874   }
30875
30876   jresult = (void *)result;
30877   return jresult;
30878 }
30879
30880
30881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30882   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30883
30884   arg1 = (Dali::HoverEvent *)jarg1;
30885   {
30886     try {
30887       delete arg1;
30888     } catch (std::out_of_range& e) {
30889       {
30890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30891       };
30892     } catch (std::exception& e) {
30893       {
30894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30895       };
30896     } catch (Dali::DaliException e) {
30897       {
30898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30899       };
30900     } catch (...) {
30901       {
30902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30903       };
30904     }
30905   }
30906
30907 }
30908
30909
30910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30911   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30912   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30913
30914   arg1 = (Dali::HoverEvent *)jarg1;
30915   arg2 = (Dali::TouchPointContainer *)jarg2;
30916   if (arg1) (arg1)->points = *arg2;
30917 }
30918
30919
30920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30921   void * jresult ;
30922   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30923   Dali::TouchPointContainer *result = 0 ;
30924
30925   arg1 = (Dali::HoverEvent *)jarg1;
30926   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30927   jresult = (void *)result;
30928   return jresult;
30929 }
30930
30931
30932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30933   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30934   unsigned long arg2 ;
30935
30936   arg1 = (Dali::HoverEvent *)jarg1;
30937   arg2 = (unsigned long)jarg2;
30938   if (arg1) (arg1)->time = arg2;
30939 }
30940
30941
30942 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30943   unsigned long jresult ;
30944   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30945   unsigned long result;
30946
30947   arg1 = (Dali::HoverEvent *)jarg1;
30948   result = (unsigned long) ((arg1)->time);
30949   jresult = (unsigned long)result;
30950   return jresult;
30951 }
30952
30953
30954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30955   unsigned int jresult ;
30956   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30957   unsigned int result;
30958
30959   arg1 = (Dali::HoverEvent *)jarg1;
30960   {
30961     try {
30962       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30963     } catch (std::out_of_range& e) {
30964       {
30965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30966       };
30967     } catch (std::exception& e) {
30968       {
30969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30970       };
30971     } catch (Dali::DaliException e) {
30972       {
30973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30974       };
30975     } catch (...) {
30976       {
30977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30978       };
30979     }
30980   }
30981
30982   jresult = result;
30983   return jresult;
30984 }
30985
30986
30987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30988   void * jresult ;
30989   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30990   unsigned int arg2 ;
30991   Dali::TouchPoint *result = 0 ;
30992
30993   arg1 = (Dali::HoverEvent *)jarg1;
30994   arg2 = (unsigned int)jarg2;
30995   {
30996     try {
30997       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30998     } catch (std::out_of_range& e) {
30999       {
31000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31001       };
31002     } catch (std::exception& e) {
31003       {
31004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31005       };
31006     } catch (Dali::DaliException e) {
31007       {
31008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31009       };
31010     } catch (...) {
31011       {
31012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31013       };
31014     }
31015   }
31016
31017   jresult = (void *)result;
31018   return jresult;
31019 }
31020
31021
31022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
31023   void * jresult ;
31024   Dali::KeyEvent *result = 0 ;
31025
31026   {
31027     try {
31028       result = (Dali::KeyEvent *)new Dali::KeyEvent();
31029     } catch (std::out_of_range& e) {
31030       {
31031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31032       };
31033     } catch (std::exception& e) {
31034       {
31035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31036       };
31037     } catch (Dali::DaliException e) {
31038       {
31039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31040       };
31041     } catch (...) {
31042       {
31043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31044       };
31045     }
31046   }
31047
31048   jresult = (void *)result;
31049   return jresult;
31050 }
31051
31052
31053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31054   void * jresult ;
31055   std::string *arg1 = 0 ;
31056   std::string *arg2 = 0 ;
31057   int arg3 ;
31058   int arg4 ;
31059   unsigned long arg5 ;
31060   Dali::KeyEvent::State *arg6 = 0 ;
31061   Dali::KeyEvent::State temp6 ;
31062   Dali::KeyEvent *result = 0 ;
31063
31064   if (!jarg1) {
31065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31066     return 0;
31067   }
31068   std::string arg1_str(jarg1);
31069   arg1 = &arg1_str;
31070   if (!jarg2) {
31071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31072     return 0;
31073   }
31074   std::string arg2_str(jarg2);
31075   arg2 = &arg2_str;
31076   arg3 = (int)jarg3;
31077   arg4 = (int)jarg4;
31078   arg5 = (unsigned long)jarg5;
31079   temp6 = (Dali::KeyEvent::State)jarg6;
31080   arg6 = &temp6;
31081   {
31082     try {
31083       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31084     } catch (std::out_of_range& e) {
31085       {
31086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31087       };
31088     } catch (std::exception& e) {
31089       {
31090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31091       };
31092     } catch (Dali::DaliException e) {
31093       {
31094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31095       };
31096     } catch (...) {
31097       {
31098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31099       };
31100     }
31101   }
31102
31103   jresult = (void *)result;
31104
31105   //argout typemap for const std::string&
31106
31107
31108   //argout typemap for const std::string&
31109
31110   return jresult;
31111 }
31112
31113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31114   void * jresult ;
31115   Dali::KeyEvent *arg1 = 0 ;
31116   Dali::KeyEvent *result = 0 ;
31117
31118   arg1 = (Dali::KeyEvent *)jarg1;
31119   if (!arg1) {
31120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31121     return 0;
31122   }
31123   {
31124     try {
31125       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31126     } catch (std::out_of_range& e) {
31127       {
31128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31129       };
31130     } catch (std::exception& e) {
31131       {
31132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31133       };
31134     } catch (Dali::DaliException e) {
31135       {
31136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31137       };
31138     } catch (...) {
31139       {
31140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31141       };
31142     }
31143   }
31144
31145   jresult = (void *)result;
31146   return jresult;
31147 }
31148
31149
31150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31151   void * jresult ;
31152   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31153   Dali::KeyEvent *arg2 = 0 ;
31154   Dali::KeyEvent *result = 0 ;
31155
31156   arg1 = (Dali::KeyEvent *)jarg1;
31157   arg2 = (Dali::KeyEvent *)jarg2;
31158   if (!arg2) {
31159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31160     return 0;
31161   }
31162   {
31163     try {
31164       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31165     } catch (std::out_of_range& e) {
31166       {
31167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31168       };
31169     } catch (std::exception& e) {
31170       {
31171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31172       };
31173     } catch (Dali::DaliException e) {
31174       {
31175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31176       };
31177     } catch (...) {
31178       {
31179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31180       };
31181     }
31182   }
31183
31184   jresult = (void *)result;
31185   return jresult;
31186 }
31187
31188
31189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31190   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31191
31192   arg1 = (Dali::KeyEvent *)jarg1;
31193   {
31194     try {
31195       delete arg1;
31196     } catch (std::out_of_range& e) {
31197       {
31198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31199       };
31200     } catch (std::exception& e) {
31201       {
31202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31203       };
31204     } catch (Dali::DaliException e) {
31205       {
31206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31207       };
31208     } catch (...) {
31209       {
31210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31211       };
31212     }
31213   }
31214
31215 }
31216
31217
31218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31219   unsigned int jresult ;
31220   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31221   bool result;
31222
31223   arg1 = (Dali::KeyEvent *)jarg1;
31224   {
31225     try {
31226       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31227     } catch (std::out_of_range& e) {
31228       {
31229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31230       };
31231     } catch (std::exception& e) {
31232       {
31233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31234       };
31235     } catch (Dali::DaliException e) {
31236       {
31237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31238       };
31239     } catch (...) {
31240       {
31241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31242       };
31243     }
31244   }
31245
31246   jresult = result;
31247   return jresult;
31248 }
31249
31250
31251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31252   unsigned int jresult ;
31253   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31254   bool result;
31255
31256   arg1 = (Dali::KeyEvent *)jarg1;
31257   {
31258     try {
31259       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31260     } catch (std::out_of_range& e) {
31261       {
31262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31263       };
31264     } catch (std::exception& e) {
31265       {
31266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31267       };
31268     } catch (Dali::DaliException e) {
31269       {
31270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31271       };
31272     } catch (...) {
31273       {
31274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31275       };
31276     }
31277   }
31278
31279   jresult = result;
31280   return jresult;
31281 }
31282
31283
31284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31285   unsigned int jresult ;
31286   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31287   bool result;
31288
31289   arg1 = (Dali::KeyEvent *)jarg1;
31290   {
31291     try {
31292       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31293     } catch (std::out_of_range& e) {
31294       {
31295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31296       };
31297     } catch (std::exception& e) {
31298       {
31299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31300       };
31301     } catch (Dali::DaliException e) {
31302       {
31303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31304       };
31305     } catch (...) {
31306       {
31307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31308       };
31309     }
31310   }
31311
31312   jresult = result;
31313   return jresult;
31314 }
31315
31316
31317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31318   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31319   std::string *arg2 = 0 ;
31320
31321   arg1 = (Dali::KeyEvent *)jarg1;
31322   if (!jarg2) {
31323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31324     return ;
31325   }
31326   std::string arg2_str(jarg2);
31327   arg2 = &arg2_str;
31328   if (arg1) (arg1)->keyPressedName = *arg2;
31329
31330   //argout typemap for const std::string&
31331
31332 }
31333
31334
31335 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31336   char * jresult ;
31337
31338   if( jarg1 == NULL )
31339   {
31340     jresult = SWIG_csharp_string_callback( "" );
31341   }
31342   else
31343   {
31344     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31345     std::string *result = 0;
31346
31347     arg1 = ( Dali::KeyEvent * )jarg1;
31348     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31349     jresult = SWIG_csharp_string_callback( result->c_str() );
31350   }
31351
31352   return jresult;
31353 }
31354
31355
31356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31357   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31358   std::string *arg2 = 0 ;
31359
31360   arg1 = (Dali::KeyEvent *)jarg1;
31361   if (!jarg2) {
31362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31363     return ;
31364   }
31365   std::string arg2_str(jarg2);
31366   arg2 = &arg2_str;
31367   if (arg1) (arg1)->keyPressed = *arg2;
31368
31369   //argout typemap for const std::string&
31370
31371 }
31372
31373
31374 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31375   char * jresult ;
31376   if( NULL == jarg1 )
31377   {
31378     jresult = SWIG_csharp_string_callback( "" );
31379   }
31380   else
31381   {
31382     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31383     std::string *result = 0;
31384
31385     arg1 = ( Dali::KeyEvent * )jarg1;
31386     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31387     jresult = SWIG_csharp_string_callback( result->c_str() );
31388   }
31389   return jresult;
31390 }
31391
31392
31393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31394   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31395   int arg2 ;
31396
31397   arg1 = (Dali::KeyEvent *)jarg1;
31398   arg2 = (int)jarg2;
31399   if (arg1) (arg1)->keyCode = arg2;
31400 }
31401
31402
31403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31404   int jresult ;
31405   if( NULL == jarg1 )
31406   {
31407     jresult = -1;
31408   }
31409   else
31410   {
31411     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31412     int result;
31413
31414     arg1 = ( Dali::KeyEvent * )jarg1;
31415     result = (int)( ( arg1 )->keyCode );
31416     jresult = result;
31417   }
31418   return jresult;
31419 }
31420
31421
31422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31423   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31424   int arg2 ;
31425
31426   arg1 = (Dali::KeyEvent *)jarg1;
31427   arg2 = (int)jarg2;
31428   if (arg1) (arg1)->keyModifier = arg2;
31429 }
31430
31431
31432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31433   int jresult ;
31434   if( jarg1 == NULL )
31435   {
31436     jresult = -1;
31437   }
31438   else
31439   {
31440     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31441     int result;
31442
31443     arg1 = ( Dali::KeyEvent * )jarg1;
31444     result = (int)( ( arg1 )->keyModifier );
31445     jresult = result;
31446   }
31447   return jresult;
31448 }
31449
31450
31451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31452   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31453   unsigned long arg2 ;
31454
31455   arg1 = (Dali::KeyEvent *)jarg1;
31456   arg2 = (unsigned long)jarg2;
31457   if (arg1) (arg1)->time = arg2;
31458 }
31459
31460
31461 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31462   unsigned long jresult ;
31463   if( jarg1 == NULL )
31464   {
31465     jresult = 0;
31466   }
31467   else
31468   {
31469     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31470     unsigned long result;
31471
31472     arg1 = ( Dali::KeyEvent * )jarg1;
31473     result = (unsigned long)( ( arg1 )->time );
31474     jresult = (unsigned long)result;
31475   }
31476   return jresult;
31477 }
31478
31479
31480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31481   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31482   Dali::KeyEvent::State arg2 ;
31483
31484   arg1 = (Dali::KeyEvent *)jarg1;
31485   arg2 = (Dali::KeyEvent::State)jarg2;
31486   if (arg1) (arg1)->state = arg2;
31487 }
31488
31489
31490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31491   int jresult ;
31492   if( jarg1 == NULL )
31493   {
31494     jresult = -1;
31495   }
31496   else
31497   {
31498     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31499     Dali::KeyEvent::State result;
31500
31501     arg1 = ( Dali::KeyEvent * )jarg1;
31502     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31503     jresult = (int)result;
31504   }
31505   return jresult;
31506 }
31507
31508 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31509   char * jresult ;
31510   std::string result;
31511   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31512
31513   arg1 = (Dali::KeyEvent *)jarg1;
31514   if (!arg1) {
31515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31516     return 0;
31517   }
31518   {
31519     try {
31520       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31521     } catch (std::out_of_range& e) {
31522       {
31523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31524       };
31525     } catch (std::exception& e) {
31526       {
31527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31528       };
31529     } catch (Dali::DaliException e) {
31530       {
31531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31532       };
31533     } catch (...) {
31534       {
31535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31536       };
31537     }
31538
31539   }
31540
31541   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31542   return jresult;
31543 }
31544
31545
31546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31547   void * jresult ;
31548   Dali::LongPressGestureDetector *result = 0 ;
31549
31550   {
31551     try {
31552       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31553     } catch (std::out_of_range& e) {
31554       {
31555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31556       };
31557     } catch (std::exception& e) {
31558       {
31559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31560       };
31561     } catch (Dali::DaliException e) {
31562       {
31563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31564       };
31565     } catch (...) {
31566       {
31567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31568       };
31569     }
31570   }
31571
31572   jresult = (void *)result;
31573   return jresult;
31574 }
31575
31576
31577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31578   void * jresult ;
31579   Dali::LongPressGestureDetector result;
31580
31581   {
31582     try {
31583       result = Dali::LongPressGestureDetector::New();
31584     } catch (std::out_of_range& e) {
31585       {
31586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31587       };
31588     } catch (std::exception& e) {
31589       {
31590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31591       };
31592     } catch (Dali::DaliException e) {
31593       {
31594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31595       };
31596     } catch (...) {
31597       {
31598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31599       };
31600     }
31601   }
31602
31603   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31604   return jresult;
31605 }
31606
31607
31608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31609   void * jresult ;
31610   unsigned int arg1 ;
31611   Dali::LongPressGestureDetector result;
31612
31613   arg1 = (unsigned int)jarg1;
31614   {
31615     try {
31616       result = Dali::LongPressGestureDetector::New(arg1);
31617     } catch (std::out_of_range& e) {
31618       {
31619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31620       };
31621     } catch (std::exception& e) {
31622       {
31623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31624       };
31625     } catch (Dali::DaliException e) {
31626       {
31627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31628       };
31629     } catch (...) {
31630       {
31631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31632       };
31633     }
31634   }
31635
31636   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31637   return jresult;
31638 }
31639
31640
31641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31642   void * jresult ;
31643   unsigned int arg1 ;
31644   unsigned int arg2 ;
31645   Dali::LongPressGestureDetector result;
31646
31647   arg1 = (unsigned int)jarg1;
31648   arg2 = (unsigned int)jarg2;
31649   {
31650     try {
31651       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31652     } catch (std::out_of_range& e) {
31653       {
31654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31655       };
31656     } catch (std::exception& e) {
31657       {
31658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31659       };
31660     } catch (Dali::DaliException e) {
31661       {
31662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31663       };
31664     } catch (...) {
31665       {
31666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31667       };
31668     }
31669   }
31670
31671   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31672   return jresult;
31673 }
31674
31675
31676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31677   void * jresult ;
31678   Dali::BaseHandle arg1 ;
31679   Dali::BaseHandle *argp1 ;
31680   Dali::LongPressGestureDetector result;
31681
31682   argp1 = (Dali::BaseHandle *)jarg1;
31683   if (!argp1) {
31684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31685     return 0;
31686   }
31687   arg1 = *argp1;
31688   {
31689     try {
31690       result = Dali::LongPressGestureDetector::DownCast(arg1);
31691     } catch (std::out_of_range& e) {
31692       {
31693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31694       };
31695     } catch (std::exception& e) {
31696       {
31697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31698       };
31699     } catch (Dali::DaliException e) {
31700       {
31701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31702       };
31703     } catch (...) {
31704       {
31705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31706       };
31707     }
31708   }
31709
31710   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31711   return jresult;
31712 }
31713
31714
31715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31716   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31717
31718   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31719   {
31720     try {
31721       delete arg1;
31722     } catch (std::out_of_range& e) {
31723       {
31724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31725       };
31726     } catch (std::exception& e) {
31727       {
31728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31729       };
31730     } catch (Dali::DaliException e) {
31731       {
31732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31733       };
31734     } catch (...) {
31735       {
31736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31737       };
31738     }
31739   }
31740
31741 }
31742
31743
31744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31745   void * jresult ;
31746   Dali::LongPressGestureDetector *arg1 = 0 ;
31747   Dali::LongPressGestureDetector *result = 0 ;
31748
31749   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31750   if (!arg1) {
31751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31752     return 0;
31753   }
31754   {
31755     try {
31756       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31757     } catch (std::out_of_range& e) {
31758       {
31759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31760       };
31761     } catch (std::exception& e) {
31762       {
31763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31764       };
31765     } catch (Dali::DaliException e) {
31766       {
31767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31768       };
31769     } catch (...) {
31770       {
31771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31772       };
31773     }
31774   }
31775
31776   jresult = (void *)result;
31777   return jresult;
31778 }
31779
31780
31781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31782   void * jresult ;
31783   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31784   Dali::LongPressGestureDetector *arg2 = 0 ;
31785   Dali::LongPressGestureDetector *result = 0 ;
31786
31787   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31788   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31789   if (!arg2) {
31790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31791     return 0;
31792   }
31793   {
31794     try {
31795       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31796     } catch (std::out_of_range& e) {
31797       {
31798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31799       };
31800     } catch (std::exception& e) {
31801       {
31802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31803       };
31804     } catch (Dali::DaliException e) {
31805       {
31806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31807       };
31808     } catch (...) {
31809       {
31810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31811       };
31812     }
31813   }
31814
31815   jresult = (void *)result;
31816   return jresult;
31817 }
31818
31819
31820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31821   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31822   unsigned int arg2 ;
31823
31824   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31825   arg2 = (unsigned int)jarg2;
31826   {
31827     try {
31828       (arg1)->SetTouchesRequired(arg2);
31829     } catch (std::out_of_range& e) {
31830       {
31831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31832       };
31833     } catch (std::exception& e) {
31834       {
31835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31836       };
31837     } catch (Dali::DaliException e) {
31838       {
31839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31840       };
31841     } catch (...) {
31842       {
31843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31844       };
31845     }
31846   }
31847
31848 }
31849
31850
31851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31852   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31853   unsigned int arg2 ;
31854   unsigned int arg3 ;
31855
31856   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31857   arg2 = (unsigned int)jarg2;
31858   arg3 = (unsigned int)jarg3;
31859   {
31860     try {
31861       (arg1)->SetTouchesRequired(arg2,arg3);
31862     } catch (std::out_of_range& e) {
31863       {
31864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31865       };
31866     } catch (std::exception& e) {
31867       {
31868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31869       };
31870     } catch (Dali::DaliException e) {
31871       {
31872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31873       };
31874     } catch (...) {
31875       {
31876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31877       };
31878     }
31879   }
31880
31881 }
31882
31883
31884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31885   unsigned int jresult ;
31886   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31887   unsigned int result;
31888
31889   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31890   {
31891     try {
31892       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31893     } catch (std::out_of_range& e) {
31894       {
31895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31896       };
31897     } catch (std::exception& e) {
31898       {
31899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31900       };
31901     } catch (Dali::DaliException e) {
31902       {
31903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31904       };
31905     } catch (...) {
31906       {
31907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31908       };
31909     }
31910   }
31911
31912   jresult = result;
31913   return jresult;
31914 }
31915
31916
31917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31918   unsigned int jresult ;
31919   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31920   unsigned int result;
31921
31922   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31923   {
31924     try {
31925       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31926     } catch (std::out_of_range& e) {
31927       {
31928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31929       };
31930     } catch (std::exception& e) {
31931       {
31932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31933       };
31934     } catch (Dali::DaliException e) {
31935       {
31936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31937       };
31938     } catch (...) {
31939       {
31940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31941       };
31942     }
31943   }
31944
31945   jresult = result;
31946   return jresult;
31947 }
31948
31949
31950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31951   void * jresult ;
31952   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31953   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31954
31955   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31956   {
31957     try {
31958       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31959     } catch (std::out_of_range& e) {
31960       {
31961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31962       };
31963     } catch (std::exception& e) {
31964       {
31965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31966       };
31967     } catch (Dali::DaliException e) {
31968       {
31969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31970       };
31971     } catch (...) {
31972       {
31973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31974       };
31975     }
31976   }
31977
31978   jresult = (void *)result;
31979   return jresult;
31980 }
31981
31982
31983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31984   void * jresult ;
31985   Dali::Gesture::State arg1 ;
31986   Dali::LongPressGesture *result = 0 ;
31987
31988   arg1 = (Dali::Gesture::State)jarg1;
31989   {
31990     try {
31991       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31992     } catch (std::out_of_range& e) {
31993       {
31994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31995       };
31996     } catch (std::exception& e) {
31997       {
31998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31999       };
32000     } catch (Dali::DaliException e) {
32001       {
32002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32003       };
32004     } catch (...) {
32005       {
32006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32007       };
32008     }
32009   }
32010
32011   jresult = (void *)result;
32012   return jresult;
32013 }
32014
32015
32016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
32017   void * jresult ;
32018   Dali::LongPressGesture *arg1 = 0 ;
32019   Dali::LongPressGesture *result = 0 ;
32020
32021   arg1 = (Dali::LongPressGesture *)jarg1;
32022   if (!arg1) {
32023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32024     return 0;
32025   }
32026   {
32027     try {
32028       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
32029     } catch (std::out_of_range& e) {
32030       {
32031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32032       };
32033     } catch (std::exception& e) {
32034       {
32035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32036       };
32037     } catch (Dali::DaliException e) {
32038       {
32039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32040       };
32041     } catch (...) {
32042       {
32043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32044       };
32045     }
32046   }
32047
32048   jresult = (void *)result;
32049   return jresult;
32050 }
32051
32052
32053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
32054   void * jresult ;
32055   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32056   Dali::LongPressGesture *arg2 = 0 ;
32057   Dali::LongPressGesture *result = 0 ;
32058
32059   arg1 = (Dali::LongPressGesture *)jarg1;
32060   arg2 = (Dali::LongPressGesture *)jarg2;
32061   if (!arg2) {
32062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32063     return 0;
32064   }
32065   {
32066     try {
32067       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
32068     } catch (std::out_of_range& e) {
32069       {
32070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32071       };
32072     } catch (std::exception& e) {
32073       {
32074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32075       };
32076     } catch (Dali::DaliException e) {
32077       {
32078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32079       };
32080     } catch (...) {
32081       {
32082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32083       };
32084     }
32085   }
32086
32087   jresult = (void *)result;
32088   return jresult;
32089 }
32090
32091
32092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32093   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32094
32095   arg1 = (Dali::LongPressGesture *)jarg1;
32096   {
32097     try {
32098       delete arg1;
32099     } catch (std::out_of_range& e) {
32100       {
32101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32102       };
32103     } catch (std::exception& e) {
32104       {
32105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32106       };
32107     } catch (Dali::DaliException e) {
32108       {
32109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32110       };
32111     } catch (...) {
32112       {
32113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32114       };
32115     }
32116   }
32117
32118 }
32119
32120
32121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32122   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32123   unsigned int arg2 ;
32124
32125   arg1 = (Dali::LongPressGesture *)jarg1;
32126   arg2 = (unsigned int)jarg2;
32127   if (arg1) (arg1)->numberOfTouches = arg2;
32128 }
32129
32130
32131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32132   unsigned int jresult ;
32133   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32134   unsigned int result;
32135
32136   arg1 = (Dali::LongPressGesture *)jarg1;
32137   result = (unsigned int) ((arg1)->numberOfTouches);
32138   jresult = result;
32139   return jresult;
32140 }
32141
32142
32143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32144   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32145   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32146
32147   arg1 = (Dali::LongPressGesture *)jarg1;
32148   arg2 = (Dali::Vector2 *)jarg2;
32149   if (arg1) (arg1)->screenPoint = *arg2;
32150 }
32151
32152
32153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32154   void * jresult ;
32155   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32156   Dali::Vector2 *result = 0 ;
32157
32158   arg1 = (Dali::LongPressGesture *)jarg1;
32159   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32160   jresult = (void *)result;
32161   return jresult;
32162 }
32163
32164
32165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32166   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32167   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32168
32169   arg1 = (Dali::LongPressGesture *)jarg1;
32170   arg2 = (Dali::Vector2 *)jarg2;
32171   if (arg1) (arg1)->localPoint = *arg2;
32172 }
32173
32174
32175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32176   void * jresult ;
32177   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32178   Dali::Vector2 *result = 0 ;
32179
32180   arg1 = (Dali::LongPressGesture *)jarg1;
32181   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32182   jresult = (void *)result;
32183   return jresult;
32184 }
32185
32186
32187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32188   void * jresult ;
32189   Dali::WheelEvent *result = 0 ;
32190
32191   {
32192     try {
32193       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32194     } catch (std::out_of_range& e) {
32195       {
32196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32197       };
32198     } catch (std::exception& e) {
32199       {
32200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32201       };
32202     } catch (Dali::DaliException e) {
32203       {
32204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32205       };
32206     } catch (...) {
32207       {
32208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32209       };
32210     }
32211   }
32212
32213   jresult = (void *)result;
32214   return jresult;
32215 }
32216
32217
32218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32219   void * jresult ;
32220   Dali::WheelEvent::Type arg1 ;
32221   int arg2 ;
32222   unsigned int arg3 ;
32223   Dali::Vector2 arg4 ;
32224   int arg5 ;
32225   unsigned int arg6 ;
32226   Dali::Vector2 *argp4 ;
32227   Dali::WheelEvent *result = 0 ;
32228
32229   arg1 = (Dali::WheelEvent::Type)jarg1;
32230   arg2 = (int)jarg2;
32231   arg3 = (unsigned int)jarg3;
32232   argp4 = (Dali::Vector2 *)jarg4;
32233   if (!argp4) {
32234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32235     return 0;
32236   }
32237   arg4 = *argp4;
32238   arg5 = (int)jarg5;
32239   arg6 = (unsigned int)jarg6;
32240   {
32241     try {
32242       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32243     } catch (std::out_of_range& e) {
32244       {
32245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32246       };
32247     } catch (std::exception& e) {
32248       {
32249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32250       };
32251     } catch (Dali::DaliException e) {
32252       {
32253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32254       };
32255     } catch (...) {
32256       {
32257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32258       };
32259     }
32260   }
32261
32262   jresult = (void *)result;
32263   return jresult;
32264 }
32265
32266
32267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32268   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32269
32270   arg1 = (Dali::WheelEvent *)jarg1;
32271   {
32272     try {
32273       delete arg1;
32274     } catch (std::out_of_range& e) {
32275       {
32276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32277       };
32278     } catch (std::exception& e) {
32279       {
32280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32281       };
32282     } catch (Dali::DaliException e) {
32283       {
32284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32285       };
32286     } catch (...) {
32287       {
32288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32289       };
32290     }
32291   }
32292
32293 }
32294
32295
32296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32297   unsigned int jresult ;
32298   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32299   bool result;
32300
32301   arg1 = (Dali::WheelEvent *)jarg1;
32302   {
32303     try {
32304       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32305     } catch (std::out_of_range& e) {
32306       {
32307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32308       };
32309     } catch (std::exception& e) {
32310       {
32311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32312       };
32313     } catch (Dali::DaliException e) {
32314       {
32315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32316       };
32317     } catch (...) {
32318       {
32319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32320       };
32321     }
32322   }
32323
32324   jresult = result;
32325   return jresult;
32326 }
32327
32328
32329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32330   unsigned int jresult ;
32331   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32332   bool result;
32333
32334   arg1 = (Dali::WheelEvent *)jarg1;
32335   {
32336     try {
32337       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32338     } catch (std::out_of_range& e) {
32339       {
32340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32341       };
32342     } catch (std::exception& e) {
32343       {
32344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32345       };
32346     } catch (Dali::DaliException e) {
32347       {
32348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32349       };
32350     } catch (...) {
32351       {
32352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32353       };
32354     }
32355   }
32356
32357   jresult = result;
32358   return jresult;
32359 }
32360
32361
32362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32363   unsigned int jresult ;
32364   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32365   bool result;
32366
32367   arg1 = (Dali::WheelEvent *)jarg1;
32368   {
32369     try {
32370       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32371     } catch (std::out_of_range& e) {
32372       {
32373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32374       };
32375     } catch (std::exception& e) {
32376       {
32377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32378       };
32379     } catch (Dali::DaliException e) {
32380       {
32381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32382       };
32383     } catch (...) {
32384       {
32385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32386       };
32387     }
32388   }
32389
32390   jresult = result;
32391   return jresult;
32392 }
32393
32394
32395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32396   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32397   Dali::WheelEvent::Type arg2 ;
32398
32399   arg1 = (Dali::WheelEvent *)jarg1;
32400   arg2 = (Dali::WheelEvent::Type)jarg2;
32401   if (arg1) (arg1)->type = arg2;
32402 }
32403
32404
32405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32406   int jresult ;
32407   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32408   Dali::WheelEvent::Type result;
32409
32410   arg1 = (Dali::WheelEvent *)jarg1;
32411   result = (Dali::WheelEvent::Type) ((arg1)->type);
32412   jresult = (int)result;
32413   return jresult;
32414 }
32415
32416
32417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32418   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32419   int arg2 ;
32420
32421   arg1 = (Dali::WheelEvent *)jarg1;
32422   arg2 = (int)jarg2;
32423   if (arg1) (arg1)->direction = arg2;
32424 }
32425
32426
32427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32428   int jresult ;
32429   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32430   int result;
32431
32432   arg1 = (Dali::WheelEvent *)jarg1;
32433   result = (int) ((arg1)->direction);
32434   jresult = result;
32435   return jresult;
32436 }
32437
32438
32439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32440   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32441   unsigned int arg2 ;
32442
32443   arg1 = (Dali::WheelEvent *)jarg1;
32444   arg2 = (unsigned int)jarg2;
32445   if (arg1) (arg1)->modifiers = arg2;
32446 }
32447
32448
32449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32450   unsigned int jresult ;
32451   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32452   unsigned int result;
32453
32454   arg1 = (Dali::WheelEvent *)jarg1;
32455   result = (unsigned int) ((arg1)->modifiers);
32456   jresult = result;
32457   return jresult;
32458 }
32459
32460
32461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32462   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32463   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32464
32465   arg1 = (Dali::WheelEvent *)jarg1;
32466   arg2 = (Dali::Vector2 *)jarg2;
32467   if (arg1) (arg1)->point = *arg2;
32468 }
32469
32470
32471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32472   void * jresult ;
32473   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32474   Dali::Vector2 *result = 0 ;
32475
32476   arg1 = (Dali::WheelEvent *)jarg1;
32477   result = (Dali::Vector2 *)& ((arg1)->point);
32478   jresult = (void *)result;
32479   return jresult;
32480 }
32481
32482
32483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32484   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32485   int arg2 ;
32486
32487   arg1 = (Dali::WheelEvent *)jarg1;
32488   arg2 = (int)jarg2;
32489   if (arg1) (arg1)->z = arg2;
32490 }
32491
32492
32493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32494   int jresult ;
32495   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32496   int result;
32497
32498   arg1 = (Dali::WheelEvent *)jarg1;
32499   result = (int) ((arg1)->z);
32500   jresult = result;
32501   return jresult;
32502 }
32503
32504
32505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32506   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32507   unsigned int arg2 ;
32508
32509   arg1 = (Dali::WheelEvent *)jarg1;
32510   arg2 = (unsigned int)jarg2;
32511   if (arg1) (arg1)->timeStamp = arg2;
32512 }
32513
32514
32515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32516   unsigned int jresult ;
32517   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32518   unsigned int result;
32519
32520   arg1 = (Dali::WheelEvent *)jarg1;
32521   result = (unsigned int) ((arg1)->timeStamp);
32522   jresult = result;
32523   return jresult;
32524 }
32525
32526 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32527   char * jresult ;
32528   Dali::KeyEvent *arg1 = 0 ;
32529   std::string result;
32530
32531   arg1 = (Dali::KeyEvent *)jarg1;
32532   if (!arg1) {
32533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32534     return 0;
32535   }
32536   {
32537     try {
32538       result = arg1->GetDeviceName();
32539     } catch (std::out_of_range& e) {
32540       {
32541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32542       };
32543     } catch (std::exception& e) {
32544       {
32545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32546       };
32547     } catch (Dali::DaliException e) {
32548       {
32549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32550       };
32551     } catch (...) {
32552       {
32553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32554       };
32555     }
32556   }
32557
32558   jresult = SWIG_csharp_string_callback((&result)->c_str());
32559   return jresult;
32560 }
32561
32562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32563   int jresult ;
32564   Dali::KeyEvent *arg1 = 0 ;
32565   Dali::Device::Class::Type result;
32566
32567   arg1 = (Dali::KeyEvent *)jarg1;
32568   if (!arg1) {
32569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32570     return 0;
32571   }
32572   {
32573     try {
32574       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32575     } catch (std::out_of_range& e) {
32576       {
32577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32578       };
32579     } catch (std::exception& e) {
32580       {
32581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32582       };
32583     } catch (Dali::DaliException e) {
32584       {
32585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32586       };
32587     } catch (...) {
32588       {
32589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32590       };
32591     }
32592   }
32593
32594   jresult = (int)result;
32595   return jresult;
32596 }
32597
32598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32599   int jresult ;
32600   Dali::KeyEvent *arg1 = 0 ;
32601   Dali::Device::Subclass::Type result;
32602
32603   arg1 = (Dali::KeyEvent *)jarg1;
32604   if (!arg1) {
32605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32606     return 0;
32607   }
32608   {
32609     try {
32610       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32611     } catch (std::out_of_range& e) {
32612       {
32613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32614       };
32615     } catch (std::exception& e) {
32616       {
32617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32618       };
32619     } catch (Dali::DaliException e) {
32620       {
32621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32622       };
32623     } catch (...) {
32624       {
32625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32626       };
32627     }
32628   }
32629
32630   jresult = (int)result;
32631   return jresult;
32632 }
32633
32634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32635   Dali::Actor arg1 ;
32636   Dali::Actor *argp1 ;
32637
32638   argp1 = (Dali::Actor *)jarg1;
32639   if (!argp1) {
32640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32641     return ;
32642   }
32643   arg1 = *argp1;
32644   {
32645     try {
32646       arg1.Raise();
32647     } catch (std::out_of_range& e) {
32648       {
32649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32650       };
32651     } catch (std::exception& e) {
32652       {
32653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32654       };
32655     } catch (Dali::DaliException e) {
32656       {
32657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32658       };
32659     } catch (...) {
32660       {
32661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32662       };
32663     }
32664   }
32665
32666 }
32667
32668
32669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32670   Dali::Actor arg1 ;
32671   Dali::Actor *argp1 ;
32672
32673   argp1 = (Dali::Actor *)jarg1;
32674   if (!argp1) {
32675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32676     return ;
32677   }
32678   arg1 = *argp1;
32679   {
32680     try {
32681       arg1.Lower();
32682     } catch (std::out_of_range& e) {
32683       {
32684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32685       };
32686     } catch (std::exception& e) {
32687       {
32688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32689       };
32690     } catch (Dali::DaliException e) {
32691       {
32692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32693       };
32694     } catch (...) {
32695       {
32696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32697       };
32698     }
32699   }
32700
32701 }
32702
32703
32704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32705   Dali::Actor arg1 ;
32706   Dali::Actor *argp1 ;
32707
32708   argp1 = (Dali::Actor *)jarg1;
32709   if (!argp1) {
32710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32711     return ;
32712   }
32713   arg1 = *argp1;
32714   {
32715     try {
32716       arg1.RaiseToTop();
32717     } catch (std::out_of_range& e) {
32718       {
32719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32720       };
32721     } catch (std::exception& e) {
32722       {
32723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32724       };
32725     } catch (Dali::DaliException e) {
32726       {
32727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32728       };
32729     } catch (...) {
32730       {
32731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32732       };
32733     }
32734   }
32735
32736 }
32737
32738
32739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32740   Dali::Actor arg1 ;
32741   Dali::Actor *argp1 ;
32742
32743   argp1 = (Dali::Actor *)jarg1;
32744   if (!argp1) {
32745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32746     return ;
32747   }
32748   arg1 = *argp1;
32749   {
32750     try {
32751       arg1.LowerToBottom();
32752     } catch (std::out_of_range& e) {
32753       {
32754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32755       };
32756     } catch (std::exception& e) {
32757       {
32758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32759       };
32760     } catch (Dali::DaliException e) {
32761       {
32762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32763       };
32764     } catch (...) {
32765       {
32766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32767       };
32768     }
32769   }
32770
32771 }
32772
32773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32774   Dali::Actor arg1 ;
32775   Dali::Actor arg2 ;
32776   Dali::Actor *argp1 ;
32777   Dali::Actor *argp2 ;
32778
32779   argp1 = (Dali::Actor *)jarg1;
32780   if (!argp1) {
32781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32782     return ;
32783   }
32784   arg1 = *argp1;
32785   argp2 = (Dali::Actor *)jarg2;
32786   if (!argp2) {
32787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32788     return ;
32789   }
32790   arg2 = *argp2;
32791   {
32792     try {
32793       arg1.RaiseAbove(arg2);
32794     } catch (std::out_of_range& e) {
32795       {
32796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32797       };
32798     } catch (std::exception& e) {
32799       {
32800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32801       };
32802     } catch (Dali::DaliException e) {
32803       {
32804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32805       };
32806     } catch (...) {
32807       {
32808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32809       };
32810     }
32811   }
32812
32813 }
32814
32815
32816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32817   Dali::Actor arg1 ;
32818   Dali::Actor arg2 ;
32819   Dali::Actor *argp1 ;
32820   Dali::Actor *argp2 ;
32821
32822   argp1 = (Dali::Actor *)jarg1;
32823   if (!argp1) {
32824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32825     return ;
32826   }
32827   arg1 = *argp1;
32828   argp2 = (Dali::Actor *)jarg2;
32829   if (!argp2) {
32830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32831     return ;
32832   }
32833   arg2 = *argp2;
32834   {
32835     try {
32836       arg1.LowerBelow(arg2);
32837     } catch (std::out_of_range& e) {
32838       {
32839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32840       };
32841     } catch (std::exception& e) {
32842       {
32843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32844       };
32845     } catch (Dali::DaliException e) {
32846       {
32847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32848       };
32849     } catch (...) {
32850       {
32851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32852       };
32853     }
32854   }
32855
32856 }
32857
32858
32859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32860   void * jresult ;
32861   Dali::Actor arg1 ;
32862   Dali::Actor *argp1 ;
32863   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32864
32865   argp1 = (Dali::Actor *)jarg1;
32866   if (!argp1) {
32867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32868     return 0;
32869   }
32870   arg1 = *argp1;
32871   {
32872     try {
32873       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32874     } catch (std::out_of_range& e) {
32875       {
32876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32877       };
32878     } catch (std::exception& e) {
32879       {
32880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32881       };
32882     } catch (Dali::DaliException e) {
32883       {
32884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32885       };
32886     } catch (...) {
32887       {
32888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32889       };
32890     }
32891   }
32892
32893   jresult = (void *)result;
32894   return jresult;
32895 }
32896
32897
32898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32899   void * jresult ;
32900   Dali::Actor *arg1 ;
32901   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32902
32903   arg1 = (Dali::Actor *)jarg1;
32904   {
32905     try {
32906       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32907     } catch (std::out_of_range& e) {
32908       {
32909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32910       };
32911     } catch (std::exception& e) {
32912       {
32913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32914       };
32915     } catch (Dali::DaliException e) {
32916       {
32917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32918       };
32919     } catch (...) {
32920       {
32921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32922       };
32923     }
32924   }
32925
32926   jresult = (void *)result;
32927   return jresult;
32928 }
32929
32930
32931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32932   int jresult ;
32933   int result;
32934
32935   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32936   jresult = (int)result;
32937   return jresult;
32938 }
32939
32940
32941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32942   int jresult ;
32943   int result;
32944
32945   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32946   jresult = (int)result;
32947   return jresult;
32948 }
32949
32950
32951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32952   int jresult ;
32953   int result;
32954
32955   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32956   jresult = (int)result;
32957   return jresult;
32958 }
32959
32960
32961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32962   int jresult ;
32963   int result;
32964
32965   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32966   jresult = (int)result;
32967   return jresult;
32968 }
32969
32970
32971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32972   int jresult ;
32973   int result;
32974
32975   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32976   jresult = (int)result;
32977   return jresult;
32978 }
32979
32980
32981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32982   int jresult ;
32983   int result;
32984
32985   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32986   jresult = (int)result;
32987   return jresult;
32988 }
32989
32990
32991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32992   int jresult ;
32993   int result;
32994
32995   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32996   jresult = (int)result;
32997   return jresult;
32998 }
32999
33000
33001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
33002   int jresult ;
33003   int result;
33004
33005   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
33006   jresult = (int)result;
33007   return jresult;
33008 }
33009
33010
33011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
33012   int jresult ;
33013   int result;
33014
33015   result = (int)Dali::Actor::Property::SIZE;
33016   jresult = (int)result;
33017   return jresult;
33018 }
33019
33020
33021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
33022   int jresult ;
33023   int result;
33024
33025   result = (int)Dali::Actor::Property::SIZE_WIDTH;
33026   jresult = (int)result;
33027   return jresult;
33028 }
33029
33030
33031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
33032   int jresult ;
33033   int result;
33034
33035   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
33036   jresult = (int)result;
33037   return jresult;
33038 }
33039
33040
33041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
33042   int jresult ;
33043   int result;
33044
33045   result = (int)Dali::Actor::Property::SIZE_DEPTH;
33046   jresult = (int)result;
33047   return jresult;
33048 }
33049
33050
33051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
33052   int jresult ;
33053   int result;
33054
33055   result = (int)Dali::Actor::Property::POSITION;
33056   jresult = (int)result;
33057   return jresult;
33058 }
33059
33060
33061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
33062   int jresult ;
33063   int result;
33064
33065   result = (int)Dali::Actor::Property::POSITION_X;
33066   jresult = (int)result;
33067   return jresult;
33068 }
33069
33070
33071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33072   int jresult ;
33073   int result;
33074
33075   result = (int)Dali::Actor::Property::POSITION_Y;
33076   jresult = (int)result;
33077   return jresult;
33078 }
33079
33080
33081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33082   int jresult ;
33083   int result;
33084
33085   result = (int)Dali::Actor::Property::POSITION_Z;
33086   jresult = (int)result;
33087   return jresult;
33088 }
33089
33090
33091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33092   int jresult ;
33093   int result;
33094
33095   result = (int)Dali::Actor::Property::WORLD_POSITION;
33096   jresult = (int)result;
33097   return jresult;
33098 }
33099
33100
33101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33102   int jresult ;
33103   int result;
33104
33105   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33106   jresult = (int)result;
33107   return jresult;
33108 }
33109
33110
33111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33112   int jresult ;
33113   int result;
33114
33115   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33116   jresult = (int)result;
33117   return jresult;
33118 }
33119
33120
33121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33122   int jresult ;
33123   int result;
33124
33125   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33126   jresult = (int)result;
33127   return jresult;
33128 }
33129
33130
33131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33132   int jresult ;
33133   int result;
33134
33135   result = (int)Dali::Actor::Property::ORIENTATION;
33136   jresult = (int)result;
33137   return jresult;
33138 }
33139
33140
33141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33142   int jresult ;
33143   int result;
33144
33145   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33146   jresult = (int)result;
33147   return jresult;
33148 }
33149
33150
33151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33152   int jresult ;
33153   int result;
33154
33155   result = (int)Dali::Actor::Property::SCALE;
33156   jresult = (int)result;
33157   return jresult;
33158 }
33159
33160
33161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33162   int jresult ;
33163   int result;
33164
33165   result = (int)Dali::Actor::Property::SCALE_X;
33166   jresult = (int)result;
33167   return jresult;
33168 }
33169
33170
33171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33172   int jresult ;
33173   int result;
33174
33175   result = (int)Dali::Actor::Property::SCALE_Y;
33176   jresult = (int)result;
33177   return jresult;
33178 }
33179
33180
33181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33182   int jresult ;
33183   int result;
33184
33185   result = (int)Dali::Actor::Property::SCALE_Z;
33186   jresult = (int)result;
33187   return jresult;
33188 }
33189
33190
33191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33192   int jresult ;
33193   int result;
33194
33195   result = (int)Dali::Actor::Property::WORLD_SCALE;
33196   jresult = (int)result;
33197   return jresult;
33198 }
33199
33200
33201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33202   int jresult ;
33203   int result;
33204
33205   result = (int)Dali::Actor::Property::VISIBLE;
33206   jresult = (int)result;
33207   return jresult;
33208 }
33209
33210
33211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33212   int jresult ;
33213   int result;
33214
33215   result = (int)Dali::Actor::Property::COLOR;
33216   jresult = (int)result;
33217   return jresult;
33218 }
33219
33220
33221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33222   int jresult ;
33223   int result;
33224
33225   result = (int)Dali::Actor::Property::COLOR_RED;
33226   jresult = (int)result;
33227   return jresult;
33228 }
33229
33230
33231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33232   int jresult ;
33233   int result;
33234
33235   result = (int)Dali::Actor::Property::COLOR_GREEN;
33236   jresult = (int)result;
33237   return jresult;
33238 }
33239
33240
33241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33242   int jresult ;
33243   int result;
33244
33245   result = (int)Dali::Actor::Property::COLOR_BLUE;
33246   jresult = (int)result;
33247   return jresult;
33248 }
33249
33250
33251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33252   int jresult ;
33253   int result;
33254
33255   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33256   jresult = (int)result;
33257   return jresult;
33258 }
33259
33260
33261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33262   int jresult ;
33263   int result;
33264
33265   result = (int)Dali::Actor::Property::WORLD_COLOR;
33266   jresult = (int)result;
33267   return jresult;
33268 }
33269
33270
33271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33272   int jresult ;
33273   int result;
33274
33275   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33276   jresult = (int)result;
33277   return jresult;
33278 }
33279
33280
33281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33282   int jresult ;
33283   int result;
33284
33285   result = (int)Dali::Actor::Property::NAME;
33286   jresult = (int)result;
33287   return jresult;
33288 }
33289
33290
33291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33292   int jresult ;
33293   int result;
33294
33295   result = (int)Dali::Actor::Property::SENSITIVE;
33296   jresult = (int)result;
33297   return jresult;
33298 }
33299
33300
33301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33302   int jresult ;
33303   int result;
33304
33305   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33306   jresult = (int)result;
33307   return jresult;
33308 }
33309
33310
33311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33312   int jresult ;
33313   int result;
33314
33315   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33316   jresult = (int)result;
33317   return jresult;
33318 }
33319
33320
33321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33322   int jresult ;
33323   int result;
33324
33325   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33326   jresult = (int)result;
33327   return jresult;
33328 }
33329
33330
33331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33332   int jresult ;
33333   int result;
33334
33335   result = (int)Dali::Actor::Property::COLOR_MODE;
33336   jresult = (int)result;
33337   return jresult;
33338 }
33339
33340
33341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33342   int jresult ;
33343   int result;
33344
33345   result = (int)Dali::Actor::Property::DRAW_MODE;
33346   jresult = (int)result;
33347   return jresult;
33348 }
33349
33350
33351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33352   int jresult ;
33353   int result;
33354
33355   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33356   jresult = (int)result;
33357   return jresult;
33358 }
33359
33360
33361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33362   int jresult ;
33363   int result;
33364
33365   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33366   jresult = (int)result;
33367   return jresult;
33368 }
33369
33370
33371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33372   int jresult ;
33373   int result;
33374
33375   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33376   jresult = (int)result;
33377   return jresult;
33378 }
33379
33380
33381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33382   int jresult ;
33383   int result;
33384
33385   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33386   jresult = (int)result;
33387   return jresult;
33388 }
33389
33390
33391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33392   int jresult ;
33393   int result;
33394
33395   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33396   jresult = (int)result;
33397   return jresult;
33398 }
33399
33400
33401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33402   int jresult ;
33403   int result;
33404
33405   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33406   jresult = (int)result;
33407   return jresult;
33408 }
33409
33410
33411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33412   int jresult ;
33413   int result;
33414
33415   result = (int)Dali::Actor::Property::PADDING;
33416   jresult = (int)result;
33417   return jresult;
33418 }
33419
33420
33421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33422   int jresult ;
33423   int result;
33424
33425   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33426   jresult = (int)result;
33427   return jresult;
33428 }
33429
33430
33431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33432   int jresult ;
33433   int result;
33434
33435   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33436   jresult = (int)result;
33437   return jresult;
33438 }
33439
33440
33441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33442   int jresult ;
33443   int result;
33444
33445   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33446   jresult = (int)result;
33447   return jresult;
33448 }
33449
33450
33451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33452   int jresult ;
33453   int result;
33454
33455   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33456   jresult = (int)result;
33457   return jresult;
33458 }
33459
33460
33461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33462   void * jresult ;
33463   Dali::Actor::Property *result = 0 ;
33464
33465   {
33466     try {
33467       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33468     } catch (std::out_of_range& e) {
33469       {
33470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33471       };
33472     } catch (std::exception& e) {
33473       {
33474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33475       };
33476     } catch (Dali::DaliException e) {
33477       {
33478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33479       };
33480     } catch (...) {
33481       {
33482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33483       };
33484     }
33485   }
33486
33487   jresult = (void *)result;
33488   return jresult;
33489 }
33490
33491
33492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33493   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33494
33495   arg1 = (Dali::Actor::Property *)jarg1;
33496   {
33497     try {
33498       delete arg1;
33499     } catch (std::out_of_range& e) {
33500       {
33501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33502       };
33503     } catch (std::exception& e) {
33504       {
33505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33506       };
33507     } catch (Dali::DaliException e) {
33508       {
33509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33510       };
33511     } catch (...) {
33512       {
33513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33514       };
33515     }
33516   }
33517
33518 }
33519
33520
33521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33522   void * jresult ;
33523   Dali::Actor *result = 0 ;
33524
33525   {
33526     try {
33527       result = (Dali::Actor *)new Dali::Actor();
33528     } catch (std::out_of_range& e) {
33529       {
33530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33531       };
33532     } catch (std::exception& e) {
33533       {
33534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33535       };
33536     } catch (Dali::DaliException e) {
33537       {
33538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33539       };
33540     } catch (...) {
33541       {
33542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33543       };
33544     }
33545   }
33546
33547   jresult = (void *)result;
33548   return jresult;
33549 }
33550
33551
33552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33553   void * jresult ;
33554   Dali::Actor result;
33555
33556   {
33557     try {
33558       result = Dali::Actor::New();
33559     } catch (std::out_of_range& e) {
33560       {
33561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33562       };
33563     } catch (std::exception& e) {
33564       {
33565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33566       };
33567     } catch (Dali::DaliException e) {
33568       {
33569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33570       };
33571     } catch (...) {
33572       {
33573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33574       };
33575     }
33576   }
33577
33578   jresult = new Dali::Actor((const Dali::Actor &)result);
33579   return jresult;
33580 }
33581
33582
33583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33584   void * jresult ;
33585   Dali::BaseHandle arg1 ;
33586   Dali::BaseHandle *argp1 ;
33587   Dali::Actor result;
33588
33589   argp1 = (Dali::BaseHandle *)jarg1;
33590   if (!argp1) {
33591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33592     return 0;
33593   }
33594   arg1 = *argp1;
33595   {
33596     try {
33597       result = Dali::Actor::DownCast(arg1);
33598     } catch (std::out_of_range& e) {
33599       {
33600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33601       };
33602     } catch (std::exception& e) {
33603       {
33604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33605       };
33606     } catch (Dali::DaliException e) {
33607       {
33608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33609       };
33610     } catch (...) {
33611       {
33612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33613       };
33614     }
33615   }
33616
33617   jresult = new Dali::Actor((const Dali::Actor &)result);
33618   return jresult;
33619 }
33620
33621
33622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33623   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33624
33625   arg1 = (Dali::Actor *)jarg1;
33626   {
33627     try {
33628       delete arg1;
33629     } catch (std::out_of_range& e) {
33630       {
33631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33632       };
33633     } catch (std::exception& e) {
33634       {
33635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33636       };
33637     } catch (Dali::DaliException e) {
33638       {
33639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33640       };
33641     } catch (...) {
33642       {
33643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33644       };
33645     }
33646   }
33647
33648 }
33649
33650
33651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33652   void * jresult ;
33653   Dali::Actor *arg1 = 0 ;
33654   Dali::Actor *result = 0 ;
33655
33656   arg1 = (Dali::Actor *)jarg1;
33657   if (!arg1) {
33658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33659     return 0;
33660   }
33661   {
33662     try {
33663       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33664     } catch (std::out_of_range& e) {
33665       {
33666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33667       };
33668     } catch (std::exception& e) {
33669       {
33670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33671       };
33672     } catch (Dali::DaliException e) {
33673       {
33674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33675       };
33676     } catch (...) {
33677       {
33678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33679       };
33680     }
33681   }
33682
33683   jresult = (void *)result;
33684   return jresult;
33685 }
33686
33687
33688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33689   void * jresult ;
33690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33691   Dali::Actor *arg2 = 0 ;
33692   Dali::Actor *result = 0 ;
33693
33694   arg1 = (Dali::Actor *)jarg1;
33695   arg2 = (Dali::Actor *)jarg2;
33696   if (!arg2) {
33697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33698     return 0;
33699   }
33700   {
33701     try {
33702       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33703     } catch (std::out_of_range& e) {
33704       {
33705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33706       };
33707     } catch (std::exception& e) {
33708       {
33709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33710       };
33711     } catch (Dali::DaliException e) {
33712       {
33713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33714       };
33715     } catch (...) {
33716       {
33717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33718       };
33719     }
33720   }
33721
33722   jresult = (void *)result;
33723   return jresult;
33724 }
33725
33726
33727 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33728   char * jresult ;
33729   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33730   std::string *result = 0 ;
33731
33732   arg1 = (Dali::Actor *)jarg1;
33733   {
33734     try {
33735       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33736     } catch (std::out_of_range& e) {
33737       {
33738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33739       };
33740     } catch (std::exception& e) {
33741       {
33742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33743       };
33744     } catch (Dali::DaliException e) {
33745       {
33746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33747       };
33748     } catch (...) {
33749       {
33750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33751       };
33752     }
33753   }
33754
33755   jresult = SWIG_csharp_string_callback(result->c_str());
33756   return jresult;
33757 }
33758
33759
33760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33761   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33762   std::string *arg2 = 0 ;
33763
33764   arg1 = (Dali::Actor *)jarg1;
33765   if (!jarg2) {
33766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33767     return ;
33768   }
33769   std::string arg2_str(jarg2);
33770   arg2 = &arg2_str;
33771   {
33772     try {
33773       (arg1)->SetName((std::string const &)*arg2);
33774     } catch (std::out_of_range& e) {
33775       {
33776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33777       };
33778     } catch (std::exception& e) {
33779       {
33780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33781       };
33782     } catch (Dali::DaliException e) {
33783       {
33784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33785       };
33786     } catch (...) {
33787       {
33788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33789       };
33790     }
33791   }
33792
33793
33794   //argout typemap for const std::string&
33795
33796 }
33797
33798
33799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33800   unsigned int jresult ;
33801   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33802   unsigned int result;
33803
33804   arg1 = (Dali::Actor *)jarg1;
33805
33806   if(!arg1) {
33807     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33808     return -1;
33809   }
33810
33811   {
33812     try {
33813       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33814     } catch (std::out_of_range& e) {
33815       {
33816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33817       };
33818     } catch (std::exception& e) {
33819       {
33820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33821       };
33822     } catch (Dali::DaliException e) {
33823       {
33824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33825       };
33826     } catch (...) {
33827       {
33828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33829       };
33830     }
33831   }
33832
33833   jresult = result;
33834   return jresult;
33835 }
33836
33837
33838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33839   unsigned int jresult ;
33840   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33841   bool result;
33842
33843   arg1 = (Dali::Actor *)jarg1;
33844   {
33845     try {
33846       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33847     } catch (std::out_of_range& e) {
33848       {
33849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33850       };
33851     } catch (std::exception& e) {
33852       {
33853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33854       };
33855     } catch (Dali::DaliException e) {
33856       {
33857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33858       };
33859     } catch (...) {
33860       {
33861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33862       };
33863     }
33864   }
33865
33866   jresult = result;
33867   return jresult;
33868 }
33869
33870
33871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33872   unsigned int jresult ;
33873   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33874   bool result;
33875
33876   arg1 = (Dali::Actor *)jarg1;
33877   {
33878     try {
33879       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33880     } catch (std::out_of_range& e) {
33881       {
33882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33883       };
33884     } catch (std::exception& e) {
33885       {
33886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33887       };
33888     } catch (Dali::DaliException e) {
33889       {
33890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33891       };
33892     } catch (...) {
33893       {
33894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33895       };
33896     }
33897   }
33898
33899   jresult = result;
33900   return jresult;
33901 }
33902
33903
33904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33905   unsigned int jresult ;
33906   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33907   bool result;
33908
33909   arg1 = (Dali::Actor *)jarg1;
33910   {
33911     try {
33912       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33913     } catch (std::out_of_range& e) {
33914       {
33915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33916       };
33917     } catch (std::exception& e) {
33918       {
33919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33920       };
33921     } catch (Dali::DaliException e) {
33922       {
33923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33924       };
33925     } catch (...) {
33926       {
33927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33928       };
33929     }
33930   }
33931
33932   jresult = result;
33933   return jresult;
33934 }
33935
33936
33937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33938   void * jresult ;
33939   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33940   Dali::Layer result;
33941
33942   arg1 = (Dali::Actor *)jarg1;
33943   {
33944     try {
33945       result = (arg1)->GetLayer();
33946     } catch (std::out_of_range& e) {
33947       {
33948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33949       };
33950     } catch (std::exception& e) {
33951       {
33952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33953       };
33954     } catch (Dali::DaliException e) {
33955       {
33956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33957       };
33958     } catch (...) {
33959       {
33960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33961       };
33962     }
33963   }
33964
33965   jresult = new Dali::Layer((const Dali::Layer &)result);
33966   return jresult;
33967 }
33968
33969
33970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33971   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33972   Dali::Actor arg2 ;
33973   Dali::Actor *argp2 ;
33974
33975   arg1 = (Dali::Actor *)jarg1;
33976   argp2 = (Dali::Actor *)jarg2;
33977   if (!argp2) {
33978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33979     return ;
33980   }
33981   arg2 = *argp2;
33982   {
33983     try {
33984       (arg1)->Add(arg2);
33985     } catch (std::out_of_range& e) {
33986       {
33987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33988       };
33989     } catch (std::exception& e) {
33990       {
33991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33992       };
33993     } catch (Dali::DaliException e) {
33994       {
33995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33996       };
33997     } catch (...) {
33998       {
33999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34000       };
34001     }
34002   }
34003
34004 }
34005
34006
34007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
34008   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34009   Dali::Actor arg2 ;
34010   Dali::Actor *argp2 ;
34011
34012   arg1 = (Dali::Actor *)jarg1;
34013   argp2 = (Dali::Actor *)jarg2;
34014   if (!argp2) {
34015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34016     return ;
34017   }
34018   arg2 = *argp2;
34019   {
34020     try {
34021       (arg1)->Remove(arg2);
34022     } catch (std::out_of_range& e) {
34023       {
34024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34025       };
34026     } catch (std::exception& e) {
34027       {
34028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34029       };
34030     } catch (Dali::DaliException e) {
34031       {
34032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34033       };
34034     } catch (...) {
34035       {
34036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34037       };
34038     }
34039   }
34040
34041 }
34042
34043
34044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34045   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34046
34047   arg1 = (Dali::Actor *)jarg1;
34048   {
34049     try {
34050       (arg1)->Unparent();
34051     } catch (std::out_of_range& e) {
34052       {
34053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34054       };
34055     } catch (std::exception& e) {
34056       {
34057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34058       };
34059     } catch (Dali::DaliException e) {
34060       {
34061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34062       };
34063     } catch (...) {
34064       {
34065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34066       };
34067     }
34068   }
34069
34070 }
34071
34072
34073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34074   unsigned int jresult ;
34075   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34076   unsigned int result;
34077
34078   arg1 = (Dali::Actor *)jarg1;
34079   {
34080     try {
34081       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34082     } catch (std::out_of_range& e) {
34083       {
34084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34085       };
34086     } catch (std::exception& e) {
34087       {
34088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34089       };
34090     } catch (Dali::DaliException e) {
34091       {
34092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34093       };
34094     } catch (...) {
34095       {
34096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34097       };
34098     }
34099   }
34100
34101   jresult = result;
34102   return jresult;
34103 }
34104
34105
34106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34107   void * jresult ;
34108   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34109   unsigned int arg2 ;
34110   Dali::Actor result;
34111
34112   arg1 = (Dali::Actor *)jarg1;
34113   arg2 = (unsigned int)jarg2;
34114   {
34115     try {
34116       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34117     } catch (std::out_of_range& e) {
34118       {
34119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34120       };
34121     } catch (std::exception& e) {
34122       {
34123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34124       };
34125     } catch (Dali::DaliException e) {
34126       {
34127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34128       };
34129     } catch (...) {
34130       {
34131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34132       };
34133     }
34134   }
34135
34136   jresult = new Dali::Actor((const Dali::Actor &)result);
34137   return jresult;
34138 }
34139
34140
34141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34142   void * jresult ;
34143   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34144   std::string *arg2 = 0 ;
34145   Dali::Actor result;
34146
34147   arg1 = (Dali::Actor *)jarg1;
34148   if (!jarg2) {
34149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34150     return 0;
34151   }
34152   std::string arg2_str(jarg2);
34153   arg2 = &arg2_str;
34154   {
34155     try {
34156       result = (arg1)->FindChildByName((std::string const &)*arg2);
34157     } catch (std::out_of_range& e) {
34158       {
34159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34160       };
34161     } catch (std::exception& e) {
34162       {
34163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34164       };
34165     } catch (Dali::DaliException e) {
34166       {
34167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34168       };
34169     } catch (...) {
34170       {
34171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34172       };
34173     }
34174   }
34175
34176   jresult = new Dali::Actor((const Dali::Actor &)result);
34177
34178   //argout typemap for const std::string&
34179
34180   return jresult;
34181 }
34182
34183
34184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34185   void * jresult ;
34186   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34187   unsigned int arg2 ;
34188   Dali::Actor result;
34189
34190   arg1 = (Dali::Actor *)jarg1;
34191   arg2 = (unsigned int)jarg2;
34192   {
34193     try {
34194       result = (arg1)->FindChildById(arg2);
34195     } catch (std::out_of_range& e) {
34196       {
34197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34198       };
34199     } catch (std::exception& e) {
34200       {
34201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34202       };
34203     } catch (Dali::DaliException e) {
34204       {
34205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34206       };
34207     } catch (...) {
34208       {
34209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34210       };
34211     }
34212   }
34213
34214   jresult = new Dali::Actor((const Dali::Actor &)result);
34215   return jresult;
34216 }
34217
34218
34219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34220   void * jresult ;
34221   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34222   Dali::Actor result;
34223
34224   arg1 = (Dali::Actor *)jarg1;
34225   {
34226     try {
34227       result = ((Dali::Actor const *)arg1)->GetParent();
34228     } catch (std::out_of_range& e) {
34229       {
34230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34231       };
34232     } catch (std::exception& e) {
34233       {
34234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34235       };
34236     } catch (Dali::DaliException e) {
34237       {
34238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34239       };
34240     } catch (...) {
34241       {
34242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34243       };
34244     }
34245   }
34246
34247   jresult = new Dali::Actor((const Dali::Actor &)result);
34248   return jresult;
34249 }
34250
34251
34252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34253   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34254   Dali::Vector3 *arg2 = 0 ;
34255
34256   arg1 = (Dali::Actor *)jarg1;
34257   arg2 = (Dali::Vector3 *)jarg2;
34258   if (!arg2) {
34259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34260     return ;
34261   }
34262   {
34263     try {
34264       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34265     } catch (std::out_of_range& e) {
34266       {
34267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34268       };
34269     } catch (std::exception& e) {
34270       {
34271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34272       };
34273     } catch (Dali::DaliException e) {
34274       {
34275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34276       };
34277     } catch (...) {
34278       {
34279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34280       };
34281     }
34282   }
34283
34284 }
34285
34286
34287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34288   void * jresult ;
34289   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34290   Dali::Vector3 result;
34291
34292   arg1 = (Dali::Actor *)jarg1;
34293   {
34294     try {
34295       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34296     } catch (std::out_of_range& e) {
34297       {
34298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34299       };
34300     } catch (std::exception& e) {
34301       {
34302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34303       };
34304     } catch (Dali::DaliException e) {
34305       {
34306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34307       };
34308     } catch (...) {
34309       {
34310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34311       };
34312     }
34313   }
34314
34315   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34316   return jresult;
34317 }
34318
34319
34320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34321   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34322   Dali::Vector3 *arg2 = 0 ;
34323
34324   arg1 = (Dali::Actor *)jarg1;
34325   arg2 = (Dali::Vector3 *)jarg2;
34326   if (!arg2) {
34327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34328     return ;
34329   }
34330   {
34331     try {
34332       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34333     } catch (std::out_of_range& e) {
34334       {
34335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34336       };
34337     } catch (std::exception& e) {
34338       {
34339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34340       };
34341     } catch (Dali::DaliException e) {
34342       {
34343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34344       };
34345     } catch (...) {
34346       {
34347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34348       };
34349     }
34350   }
34351
34352 }
34353
34354
34355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34356   void * jresult ;
34357   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34358   Dali::Vector3 result;
34359
34360   arg1 = (Dali::Actor *)jarg1;
34361   {
34362     try {
34363       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34364     } catch (std::out_of_range& e) {
34365       {
34366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34367       };
34368     } catch (std::exception& e) {
34369       {
34370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34371       };
34372     } catch (Dali::DaliException e) {
34373       {
34374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34375       };
34376     } catch (...) {
34377       {
34378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34379       };
34380     }
34381   }
34382
34383   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34384   return jresult;
34385 }
34386
34387
34388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34389   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34390   float arg2 ;
34391   float arg3 ;
34392
34393   arg1 = (Dali::Actor *)jarg1;
34394   arg2 = (float)jarg2;
34395   arg3 = (float)jarg3;
34396   {
34397     try {
34398       (arg1)->SetSize(arg2,arg3);
34399     } catch (std::out_of_range& e) {
34400       {
34401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34402       };
34403     } catch (std::exception& e) {
34404       {
34405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34406       };
34407     } catch (Dali::DaliException e) {
34408       {
34409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34410       };
34411     } catch (...) {
34412       {
34413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34414       };
34415     }
34416   }
34417
34418 }
34419
34420
34421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34422   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34423   float arg2 ;
34424   float arg3 ;
34425   float arg4 ;
34426
34427   arg1 = (Dali::Actor *)jarg1;
34428   arg2 = (float)jarg2;
34429   arg3 = (float)jarg3;
34430   arg4 = (float)jarg4;
34431   {
34432     try {
34433       (arg1)->SetSize(arg2,arg3,arg4);
34434     } catch (std::out_of_range& e) {
34435       {
34436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34437       };
34438     } catch (std::exception& e) {
34439       {
34440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34441       };
34442     } catch (Dali::DaliException e) {
34443       {
34444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34445       };
34446     } catch (...) {
34447       {
34448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34449       };
34450     }
34451   }
34452
34453 }
34454
34455
34456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34457   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34458   Dali::Vector2 *arg2 = 0 ;
34459
34460   arg1 = (Dali::Actor *)jarg1;
34461   arg2 = (Dali::Vector2 *)jarg2;
34462   if (!arg2) {
34463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34464     return ;
34465   }
34466   {
34467     try {
34468       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34469     } catch (std::out_of_range& e) {
34470       {
34471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34472       };
34473     } catch (std::exception& e) {
34474       {
34475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34476       };
34477     } catch (Dali::DaliException e) {
34478       {
34479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34480       };
34481     } catch (...) {
34482       {
34483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34484       };
34485     }
34486   }
34487
34488 }
34489
34490
34491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34492   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34493   Dali::Vector3 *arg2 = 0 ;
34494
34495   arg1 = (Dali::Actor *)jarg1;
34496   arg2 = (Dali::Vector3 *)jarg2;
34497   if (!arg2) {
34498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34499     return ;
34500   }
34501   {
34502     try {
34503       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34504     } catch (std::out_of_range& e) {
34505       {
34506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34507       };
34508     } catch (std::exception& e) {
34509       {
34510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34511       };
34512     } catch (Dali::DaliException e) {
34513       {
34514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34515       };
34516     } catch (...) {
34517       {
34518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34519       };
34520     }
34521   }
34522
34523 }
34524
34525
34526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34527   void * jresult ;
34528   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34529   Dali::Vector3 result;
34530
34531   arg1 = (Dali::Actor *)jarg1;
34532   {
34533     try {
34534       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34535     } catch (std::out_of_range& e) {
34536       {
34537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34538       };
34539     } catch (std::exception& e) {
34540       {
34541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34542       };
34543     } catch (Dali::DaliException e) {
34544       {
34545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34546       };
34547     } catch (...) {
34548       {
34549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34550       };
34551     }
34552   }
34553
34554   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34555   return jresult;
34556 }
34557
34558
34559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34560   void * jresult ;
34561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34562   Dali::Vector3 result;
34563
34564   arg1 = (Dali::Actor *)jarg1;
34565   {
34566     try {
34567       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34568     } catch (std::out_of_range& e) {
34569       {
34570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34571       };
34572     } catch (std::exception& e) {
34573       {
34574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34575       };
34576     } catch (Dali::DaliException e) {
34577       {
34578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34579       };
34580     } catch (...) {
34581       {
34582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34583       };
34584     }
34585   }
34586
34587   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34588   return jresult;
34589 }
34590
34591
34592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34593   void * jresult ;
34594   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34595   Dali::Vector3 result;
34596
34597   arg1 = (Dali::Actor *)jarg1;
34598   {
34599     try {
34600       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34601     } catch (std::out_of_range& e) {
34602       {
34603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34604       };
34605     } catch (std::exception& e) {
34606       {
34607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34608       };
34609     } catch (Dali::DaliException e) {
34610       {
34611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34612       };
34613     } catch (...) {
34614       {
34615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34616       };
34617     }
34618   }
34619
34620   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34621   return jresult;
34622 }
34623
34624
34625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34626   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34627   float arg2 ;
34628   float arg3 ;
34629
34630   arg1 = (Dali::Actor *)jarg1;
34631   arg2 = (float)jarg2;
34632   arg3 = (float)jarg3;
34633   {
34634     try {
34635       (arg1)->SetPosition(arg2,arg3);
34636     } catch (std::out_of_range& e) {
34637       {
34638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34639       };
34640     } catch (std::exception& e) {
34641       {
34642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34643       };
34644     } catch (Dali::DaliException e) {
34645       {
34646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34647       };
34648     } catch (...) {
34649       {
34650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34651       };
34652     }
34653   }
34654
34655 }
34656
34657
34658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34659   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34660   float arg2 ;
34661   float arg3 ;
34662   float arg4 ;
34663
34664   arg1 = (Dali::Actor *)jarg1;
34665   arg2 = (float)jarg2;
34666   arg3 = (float)jarg3;
34667   arg4 = (float)jarg4;
34668   {
34669     try {
34670       (arg1)->SetPosition(arg2,arg3,arg4);
34671     } catch (std::out_of_range& e) {
34672       {
34673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34674       };
34675     } catch (std::exception& e) {
34676       {
34677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34678       };
34679     } catch (Dali::DaliException e) {
34680       {
34681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34682       };
34683     } catch (...) {
34684       {
34685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34686       };
34687     }
34688   }
34689
34690 }
34691
34692
34693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34694   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34695   Dali::Vector3 *arg2 = 0 ;
34696
34697   arg1 = (Dali::Actor *)jarg1;
34698   arg2 = (Dali::Vector3 *)jarg2;
34699   if (!arg2) {
34700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34701     return ;
34702   }
34703   {
34704     try {
34705       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34706     } catch (std::out_of_range& e) {
34707       {
34708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34709       };
34710     } catch (std::exception& e) {
34711       {
34712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34713       };
34714     } catch (Dali::DaliException e) {
34715       {
34716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34717       };
34718     } catch (...) {
34719       {
34720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34721       };
34722     }
34723   }
34724
34725 }
34726
34727
34728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34729   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34730   float arg2 ;
34731
34732   arg1 = (Dali::Actor *)jarg1;
34733   arg2 = (float)jarg2;
34734   {
34735     try {
34736       (arg1)->SetX(arg2);
34737     } catch (std::out_of_range& e) {
34738       {
34739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34740       };
34741     } catch (std::exception& e) {
34742       {
34743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34744       };
34745     } catch (Dali::DaliException e) {
34746       {
34747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34748       };
34749     } catch (...) {
34750       {
34751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34752       };
34753     }
34754   }
34755
34756 }
34757
34758
34759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34761   float arg2 ;
34762
34763   arg1 = (Dali::Actor *)jarg1;
34764   arg2 = (float)jarg2;
34765   {
34766     try {
34767       (arg1)->SetY(arg2);
34768     } catch (std::out_of_range& e) {
34769       {
34770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34771       };
34772     } catch (std::exception& e) {
34773       {
34774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34775       };
34776     } catch (Dali::DaliException e) {
34777       {
34778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34779       };
34780     } catch (...) {
34781       {
34782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34783       };
34784     }
34785   }
34786
34787 }
34788
34789
34790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34791   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34792   float arg2 ;
34793
34794   arg1 = (Dali::Actor *)jarg1;
34795   arg2 = (float)jarg2;
34796   {
34797     try {
34798       (arg1)->SetZ(arg2);
34799     } catch (std::out_of_range& e) {
34800       {
34801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34802       };
34803     } catch (std::exception& e) {
34804       {
34805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34806       };
34807     } catch (Dali::DaliException e) {
34808       {
34809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34810       };
34811     } catch (...) {
34812       {
34813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34814       };
34815     }
34816   }
34817
34818 }
34819
34820
34821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34822   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34823   Dali::Vector3 *arg2 = 0 ;
34824
34825   arg1 = (Dali::Actor *)jarg1;
34826   arg2 = (Dali::Vector3 *)jarg2;
34827   if (!arg2) {
34828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34829     return ;
34830   }
34831   {
34832     try {
34833       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34834     } catch (std::out_of_range& e) {
34835       {
34836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34837       };
34838     } catch (std::exception& e) {
34839       {
34840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34841       };
34842     } catch (Dali::DaliException e) {
34843       {
34844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34845       };
34846     } catch (...) {
34847       {
34848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34849       };
34850     }
34851   }
34852
34853 }
34854
34855
34856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34857   void * jresult ;
34858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34859   Dali::Vector3 result;
34860
34861   arg1 = (Dali::Actor *)jarg1;
34862   {
34863     try {
34864       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34865     } catch (std::out_of_range& e) {
34866       {
34867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34868       };
34869     } catch (std::exception& e) {
34870       {
34871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34872       };
34873     } catch (Dali::DaliException e) {
34874       {
34875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34876       };
34877     } catch (...) {
34878       {
34879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34880       };
34881     }
34882   }
34883
34884   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34885   return jresult;
34886 }
34887
34888
34889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34890   void * jresult ;
34891   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34892   Dali::Vector3 result;
34893
34894   arg1 = (Dali::Actor *)jarg1;
34895   {
34896     try {
34897       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34898     } catch (std::out_of_range& e) {
34899       {
34900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34901       };
34902     } catch (std::exception& e) {
34903       {
34904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34905       };
34906     } catch (Dali::DaliException e) {
34907       {
34908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34909       };
34910     } catch (...) {
34911       {
34912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34913       };
34914     }
34915   }
34916
34917   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34918   return jresult;
34919 }
34920
34921
34922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34923   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34924   bool arg2 ;
34925
34926   arg1 = (Dali::Actor *)jarg1;
34927   arg2 = jarg2 ? true : false;
34928   {
34929     try {
34930       (arg1)->SetInheritPosition(arg2);
34931     } catch (std::out_of_range& e) {
34932       {
34933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34934       };
34935     } catch (std::exception& e) {
34936       {
34937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34938       };
34939     } catch (Dali::DaliException e) {
34940       {
34941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34942       };
34943     } catch (...) {
34944       {
34945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34946       };
34947     }
34948   }
34949
34950 }
34951
34952
34953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34954   unsigned int jresult ;
34955   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34956   bool result;
34957
34958   arg1 = (Dali::Actor *)jarg1;
34959   {
34960     try {
34961       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34962     } catch (std::out_of_range& e) {
34963       {
34964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34965       };
34966     } catch (std::exception& e) {
34967       {
34968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34969       };
34970     } catch (Dali::DaliException e) {
34971       {
34972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34973       };
34974     } catch (...) {
34975       {
34976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34977       };
34978     }
34979   }
34980
34981   jresult = result;
34982   return jresult;
34983 }
34984
34985
34986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34987   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34988   Dali::Degree *arg2 = 0 ;
34989   Dali::Vector3 *arg3 = 0 ;
34990
34991   arg1 = (Dali::Actor *)jarg1;
34992   arg2 = (Dali::Degree *)jarg2;
34993   if (!arg2) {
34994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34995     return ;
34996   }
34997   arg3 = (Dali::Vector3 *)jarg3;
34998   if (!arg3) {
34999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35000     return ;
35001   }
35002   {
35003     try {
35004       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35005     } catch (std::out_of_range& e) {
35006       {
35007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35008       };
35009     } catch (std::exception& e) {
35010       {
35011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35012       };
35013     } catch (Dali::DaliException e) {
35014       {
35015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35016       };
35017     } catch (...) {
35018       {
35019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35020       };
35021     }
35022   }
35023
35024 }
35025
35026
35027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35029   Dali::Radian *arg2 = 0 ;
35030   Dali::Vector3 *arg3 = 0 ;
35031
35032   arg1 = (Dali::Actor *)jarg1;
35033   arg2 = (Dali::Radian *)jarg2;
35034   if (!arg2) {
35035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35036     return ;
35037   }
35038   arg3 = (Dali::Vector3 *)jarg3;
35039   if (!arg3) {
35040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35041     return ;
35042   }
35043   {
35044     try {
35045       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35046     } catch (std::out_of_range& e) {
35047       {
35048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35049       };
35050     } catch (std::exception& e) {
35051       {
35052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35053       };
35054     } catch (Dali::DaliException e) {
35055       {
35056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35057       };
35058     } catch (...) {
35059       {
35060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35061       };
35062     }
35063   }
35064
35065 }
35066
35067
35068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35069   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35070   Dali::Quaternion *arg2 = 0 ;
35071
35072   arg1 = (Dali::Actor *)jarg1;
35073   arg2 = (Dali::Quaternion *)jarg2;
35074   if (!arg2) {
35075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35076     return ;
35077   }
35078   {
35079     try {
35080       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35081     } catch (std::out_of_range& e) {
35082       {
35083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35084       };
35085     } catch (std::exception& e) {
35086       {
35087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35088       };
35089     } catch (Dali::DaliException e) {
35090       {
35091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35092       };
35093     } catch (...) {
35094       {
35095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35096       };
35097     }
35098   }
35099
35100 }
35101
35102
35103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35104   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35105   Dali::Degree *arg2 = 0 ;
35106   Dali::Vector3 *arg3 = 0 ;
35107
35108   arg1 = (Dali::Actor *)jarg1;
35109   arg2 = (Dali::Degree *)jarg2;
35110   if (!arg2) {
35111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35112     return ;
35113   }
35114   arg3 = (Dali::Vector3 *)jarg3;
35115   if (!arg3) {
35116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35117     return ;
35118   }
35119   {
35120     try {
35121       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35122     } catch (std::out_of_range& e) {
35123       {
35124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35125       };
35126     } catch (std::exception& e) {
35127       {
35128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35129       };
35130     } catch (Dali::DaliException e) {
35131       {
35132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35133       };
35134     } catch (...) {
35135       {
35136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35137       };
35138     }
35139   }
35140
35141 }
35142
35143
35144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35145   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35146   Dali::Radian *arg2 = 0 ;
35147   Dali::Vector3 *arg3 = 0 ;
35148
35149   arg1 = (Dali::Actor *)jarg1;
35150   arg2 = (Dali::Radian *)jarg2;
35151   if (!arg2) {
35152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35153     return ;
35154   }
35155   arg3 = (Dali::Vector3 *)jarg3;
35156   if (!arg3) {
35157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35158     return ;
35159   }
35160   {
35161     try {
35162       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35163     } catch (std::out_of_range& e) {
35164       {
35165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35166       };
35167     } catch (std::exception& e) {
35168       {
35169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35170       };
35171     } catch (Dali::DaliException e) {
35172       {
35173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35174       };
35175     } catch (...) {
35176       {
35177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35178       };
35179     }
35180   }
35181
35182 }
35183
35184
35185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35186   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35187   Dali::Quaternion *arg2 = 0 ;
35188
35189   arg1 = (Dali::Actor *)jarg1;
35190   arg2 = (Dali::Quaternion *)jarg2;
35191   if (!arg2) {
35192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35193     return ;
35194   }
35195   {
35196     try {
35197       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35198     } catch (std::out_of_range& e) {
35199       {
35200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35201       };
35202     } catch (std::exception& e) {
35203       {
35204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35205       };
35206     } catch (Dali::DaliException e) {
35207       {
35208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35209       };
35210     } catch (...) {
35211       {
35212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35213       };
35214     }
35215   }
35216
35217 }
35218
35219
35220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35221   void * jresult ;
35222   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35223   Dali::Quaternion result;
35224
35225   arg1 = (Dali::Actor *)jarg1;
35226   {
35227     try {
35228       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35229     } catch (std::out_of_range& e) {
35230       {
35231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35232       };
35233     } catch (std::exception& e) {
35234       {
35235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35236       };
35237     } catch (Dali::DaliException e) {
35238       {
35239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35240       };
35241     } catch (...) {
35242       {
35243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35244       };
35245     }
35246   }
35247
35248   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35249   return jresult;
35250 }
35251
35252
35253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35254   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35255   bool arg2 ;
35256
35257   arg1 = (Dali::Actor *)jarg1;
35258   arg2 = jarg2 ? true : false;
35259   {
35260     try {
35261       (arg1)->SetInheritOrientation(arg2);
35262     } catch (std::out_of_range& e) {
35263       {
35264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35265       };
35266     } catch (std::exception& e) {
35267       {
35268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35269       };
35270     } catch (Dali::DaliException e) {
35271       {
35272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35273       };
35274     } catch (...) {
35275       {
35276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35277       };
35278     }
35279   }
35280
35281 }
35282
35283
35284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35285   unsigned int jresult ;
35286   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35287   bool result;
35288
35289   arg1 = (Dali::Actor *)jarg1;
35290   {
35291     try {
35292       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35293     } catch (std::out_of_range& e) {
35294       {
35295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35296       };
35297     } catch (std::exception& e) {
35298       {
35299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35300       };
35301     } catch (Dali::DaliException e) {
35302       {
35303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35304       };
35305     } catch (...) {
35306       {
35307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35308       };
35309     }
35310   }
35311
35312   jresult = result;
35313   return jresult;
35314 }
35315
35316
35317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35318   void * jresult ;
35319   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35320   Dali::Quaternion result;
35321
35322   arg1 = (Dali::Actor *)jarg1;
35323   {
35324     try {
35325       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35326     } catch (std::out_of_range& e) {
35327       {
35328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35329       };
35330     } catch (std::exception& e) {
35331       {
35332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35333       };
35334     } catch (Dali::DaliException e) {
35335       {
35336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35337       };
35338     } catch (...) {
35339       {
35340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35341       };
35342     }
35343   }
35344
35345   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35346   return jresult;
35347 }
35348
35349
35350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35351   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35352   float arg2 ;
35353
35354   arg1 = (Dali::Actor *)jarg1;
35355   arg2 = (float)jarg2;
35356   {
35357     try {
35358       (arg1)->SetScale(arg2);
35359     } catch (std::out_of_range& e) {
35360       {
35361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35362       };
35363     } catch (std::exception& e) {
35364       {
35365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35366       };
35367     } catch (Dali::DaliException e) {
35368       {
35369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35370       };
35371     } catch (...) {
35372       {
35373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35374       };
35375     }
35376   }
35377
35378 }
35379
35380
35381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35382   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35383   float arg2 ;
35384   float arg3 ;
35385   float arg4 ;
35386
35387   arg1 = (Dali::Actor *)jarg1;
35388   arg2 = (float)jarg2;
35389   arg3 = (float)jarg3;
35390   arg4 = (float)jarg4;
35391   {
35392     try {
35393       (arg1)->SetScale(arg2,arg3,arg4);
35394     } catch (std::out_of_range& e) {
35395       {
35396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35397       };
35398     } catch (std::exception& e) {
35399       {
35400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35401       };
35402     } catch (Dali::DaliException e) {
35403       {
35404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35405       };
35406     } catch (...) {
35407       {
35408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35409       };
35410     }
35411   }
35412
35413 }
35414
35415
35416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35417   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35418   Dali::Vector3 *arg2 = 0 ;
35419
35420   arg1 = (Dali::Actor *)jarg1;
35421   arg2 = (Dali::Vector3 *)jarg2;
35422   if (!arg2) {
35423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35424     return ;
35425   }
35426   {
35427     try {
35428       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35429     } catch (std::out_of_range& e) {
35430       {
35431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35432       };
35433     } catch (std::exception& e) {
35434       {
35435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35436       };
35437     } catch (Dali::DaliException e) {
35438       {
35439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35440       };
35441     } catch (...) {
35442       {
35443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35444       };
35445     }
35446   }
35447
35448 }
35449
35450
35451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35452   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35453   Dali::Vector3 *arg2 = 0 ;
35454
35455   arg1 = (Dali::Actor *)jarg1;
35456   arg2 = (Dali::Vector3 *)jarg2;
35457   if (!arg2) {
35458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35459     return ;
35460   }
35461   {
35462     try {
35463       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35464     } catch (std::out_of_range& e) {
35465       {
35466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35467       };
35468     } catch (std::exception& e) {
35469       {
35470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35471       };
35472     } catch (Dali::DaliException e) {
35473       {
35474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35475       };
35476     } catch (...) {
35477       {
35478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35479       };
35480     }
35481   }
35482
35483 }
35484
35485
35486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35487   void * jresult ;
35488   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35489   Dali::Vector3 result;
35490
35491   arg1 = (Dali::Actor *)jarg1;
35492   {
35493     try {
35494       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35495     } catch (std::out_of_range& e) {
35496       {
35497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35498       };
35499     } catch (std::exception& e) {
35500       {
35501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35502       };
35503     } catch (Dali::DaliException e) {
35504       {
35505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35506       };
35507     } catch (...) {
35508       {
35509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35510       };
35511     }
35512   }
35513
35514   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35515   return jresult;
35516 }
35517
35518
35519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35520   void * jresult ;
35521   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35522   Dali::Vector3 result;
35523
35524   arg1 = (Dali::Actor *)jarg1;
35525   {
35526     try {
35527       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35528     } catch (std::out_of_range& e) {
35529       {
35530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35531       };
35532     } catch (std::exception& e) {
35533       {
35534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35535       };
35536     } catch (Dali::DaliException e) {
35537       {
35538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35539       };
35540     } catch (...) {
35541       {
35542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35543       };
35544     }
35545   }
35546
35547   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35548   return jresult;
35549 }
35550
35551
35552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35553   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35554   bool arg2 ;
35555
35556   arg1 = (Dali::Actor *)jarg1;
35557   arg2 = jarg2 ? true : false;
35558   {
35559     try {
35560       (arg1)->SetInheritScale(arg2);
35561     } catch (std::out_of_range& e) {
35562       {
35563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35564       };
35565     } catch (std::exception& e) {
35566       {
35567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35568       };
35569     } catch (Dali::DaliException e) {
35570       {
35571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35572       };
35573     } catch (...) {
35574       {
35575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35576       };
35577     }
35578   }
35579
35580 }
35581
35582
35583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35584   unsigned int jresult ;
35585   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35586   bool result;
35587
35588   arg1 = (Dali::Actor *)jarg1;
35589   {
35590     try {
35591       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35592     } catch (std::out_of_range& e) {
35593       {
35594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35595       };
35596     } catch (std::exception& e) {
35597       {
35598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35599       };
35600     } catch (Dali::DaliException e) {
35601       {
35602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35603       };
35604     } catch (...) {
35605       {
35606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35607       };
35608     }
35609   }
35610
35611   jresult = result;
35612   return jresult;
35613 }
35614
35615
35616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35617   void * jresult ;
35618   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35619   Dali::Matrix result;
35620
35621   arg1 = (Dali::Actor *)jarg1;
35622   {
35623     try {
35624       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35625     } catch (std::out_of_range& e) {
35626       {
35627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35628       };
35629     } catch (std::exception& e) {
35630       {
35631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35632       };
35633     } catch (Dali::DaliException e) {
35634       {
35635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35636       };
35637     } catch (...) {
35638       {
35639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35640       };
35641     }
35642   }
35643
35644   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35645   return jresult;
35646 }
35647
35648
35649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35650   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35651   bool arg2 ;
35652
35653   arg1 = (Dali::Actor *)jarg1;
35654   arg2 = jarg2 ? true : false;
35655   {
35656     try {
35657       (arg1)->SetVisible(arg2);
35658     } catch (std::out_of_range& e) {
35659       {
35660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35661       };
35662     } catch (std::exception& e) {
35663       {
35664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35665       };
35666     } catch (Dali::DaliException e) {
35667       {
35668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35669       };
35670     } catch (...) {
35671       {
35672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35673       };
35674     }
35675   }
35676
35677 }
35678
35679
35680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35681   unsigned int jresult ;
35682   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35683   bool result;
35684
35685   arg1 = (Dali::Actor *)jarg1;
35686   {
35687     try {
35688       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35689     } catch (std::out_of_range& e) {
35690       {
35691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35692       };
35693     } catch (std::exception& e) {
35694       {
35695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35696       };
35697     } catch (Dali::DaliException e) {
35698       {
35699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35700       };
35701     } catch (...) {
35702       {
35703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35704       };
35705     }
35706   }
35707
35708   jresult = result;
35709   return jresult;
35710 }
35711
35712
35713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35714   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35715   float arg2 ;
35716
35717   arg1 = (Dali::Actor *)jarg1;
35718   arg2 = (float)jarg2;
35719   {
35720     try {
35721       (arg1)->SetOpacity(arg2);
35722     } catch (std::out_of_range& e) {
35723       {
35724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35725       };
35726     } catch (std::exception& e) {
35727       {
35728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35729       };
35730     } catch (Dali::DaliException e) {
35731       {
35732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35733       };
35734     } catch (...) {
35735       {
35736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35737       };
35738     }
35739   }
35740
35741 }
35742
35743
35744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35745   float jresult ;
35746   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35747   float result;
35748
35749   arg1 = (Dali::Actor *)jarg1;
35750   {
35751     try {
35752       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35753     } catch (std::out_of_range& e) {
35754       {
35755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35756       };
35757     } catch (std::exception& e) {
35758       {
35759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35760       };
35761     } catch (Dali::DaliException e) {
35762       {
35763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35764       };
35765     } catch (...) {
35766       {
35767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35768       };
35769     }
35770   }
35771
35772   jresult = result;
35773   return jresult;
35774 }
35775
35776
35777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35778   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35779   Dali::Vector4 *arg2 = 0 ;
35780
35781   arg1 = (Dali::Actor *)jarg1;
35782   arg2 = (Dali::Vector4 *)jarg2;
35783   if (!arg2) {
35784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35785     return ;
35786   }
35787   {
35788     try {
35789       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35790     } catch (std::out_of_range& e) {
35791       {
35792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35793       };
35794     } catch (std::exception& e) {
35795       {
35796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35797       };
35798     } catch (Dali::DaliException e) {
35799       {
35800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35801       };
35802     } catch (...) {
35803       {
35804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35805       };
35806     }
35807   }
35808
35809 }
35810
35811
35812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35813   void * jresult ;
35814   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35815   Dali::Vector4 result;
35816
35817   arg1 = (Dali::Actor *)jarg1;
35818   {
35819     try {
35820       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35821     } catch (std::out_of_range& e) {
35822       {
35823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35824       };
35825     } catch (std::exception& e) {
35826       {
35827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35828       };
35829     } catch (Dali::DaliException e) {
35830       {
35831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35832       };
35833     } catch (...) {
35834       {
35835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35836       };
35837     }
35838   }
35839
35840   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35841   return jresult;
35842 }
35843
35844
35845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35846   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35847   Dali::ColorMode arg2 ;
35848
35849   arg1 = (Dali::Actor *)jarg1;
35850   arg2 = (Dali::ColorMode)jarg2;
35851   {
35852     try {
35853       (arg1)->SetColorMode(arg2);
35854     } catch (std::out_of_range& e) {
35855       {
35856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35857       };
35858     } catch (std::exception& e) {
35859       {
35860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35861       };
35862     } catch (Dali::DaliException e) {
35863       {
35864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35865       };
35866     } catch (...) {
35867       {
35868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35869       };
35870     }
35871   }
35872
35873 }
35874
35875
35876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35877   int jresult ;
35878   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35879   Dali::ColorMode result;
35880
35881   arg1 = (Dali::Actor *)jarg1;
35882   {
35883     try {
35884       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35885     } catch (std::out_of_range& e) {
35886       {
35887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35888       };
35889     } catch (std::exception& e) {
35890       {
35891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35892       };
35893     } catch (Dali::DaliException e) {
35894       {
35895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35896       };
35897     } catch (...) {
35898       {
35899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35900       };
35901     }
35902   }
35903
35904   jresult = (int)result;
35905   return jresult;
35906 }
35907
35908
35909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35910   void * jresult ;
35911   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35912   Dali::Vector4 result;
35913
35914   arg1 = (Dali::Actor *)jarg1;
35915   {
35916     try {
35917       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35918     } catch (std::out_of_range& e) {
35919       {
35920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35921       };
35922     } catch (std::exception& e) {
35923       {
35924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35925       };
35926     } catch (Dali::DaliException e) {
35927       {
35928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35929       };
35930     } catch (...) {
35931       {
35932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35933       };
35934     }
35935   }
35936
35937   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35938   return jresult;
35939 }
35940
35941
35942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35944   Dali::DrawMode::Type arg2 ;
35945
35946   arg1 = (Dali::Actor *)jarg1;
35947   arg2 = (Dali::DrawMode::Type)jarg2;
35948   {
35949     try {
35950       (arg1)->SetDrawMode(arg2);
35951     } catch (std::out_of_range& e) {
35952       {
35953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35954       };
35955     } catch (std::exception& e) {
35956       {
35957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35958       };
35959     } catch (Dali::DaliException e) {
35960       {
35961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35962       };
35963     } catch (...) {
35964       {
35965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35966       };
35967     }
35968   }
35969
35970 }
35971
35972
35973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35974   int jresult ;
35975   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35976   Dali::DrawMode::Type result;
35977
35978   arg1 = (Dali::Actor *)jarg1;
35979   {
35980     try {
35981       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35982     } catch (std::out_of_range& e) {
35983       {
35984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35985       };
35986     } catch (std::exception& e) {
35987       {
35988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35989       };
35990     } catch (Dali::DaliException e) {
35991       {
35992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35993       };
35994     } catch (...) {
35995       {
35996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35997       };
35998     }
35999   }
36000
36001   jresult = (int)result;
36002   return jresult;
36003 }
36004
36005
36006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
36007   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36008   bool arg2 ;
36009
36010   arg1 = (Dali::Actor *)jarg1;
36011   arg2 = jarg2 ? true : false;
36012   {
36013     try {
36014       (arg1)->SetSensitive(arg2);
36015     } catch (std::out_of_range& e) {
36016       {
36017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36018       };
36019     } catch (std::exception& e) {
36020       {
36021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36022       };
36023     } catch (Dali::DaliException e) {
36024       {
36025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36026       };
36027     } catch (...) {
36028       {
36029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36030       };
36031     }
36032   }
36033
36034 }
36035
36036
36037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36038   unsigned int jresult ;
36039   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36040   bool result;
36041
36042   arg1 = (Dali::Actor *)jarg1;
36043   {
36044     try {
36045       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
36046     } catch (std::out_of_range& e) {
36047       {
36048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36049       };
36050     } catch (std::exception& e) {
36051       {
36052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36053       };
36054     } catch (Dali::DaliException e) {
36055       {
36056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36057       };
36058     } catch (...) {
36059       {
36060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36061       };
36062     }
36063   }
36064
36065   jresult = result;
36066   return jresult;
36067 }
36068
36069
36070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36071   unsigned int jresult ;
36072   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36073   float *arg2 = 0 ;
36074   float *arg3 = 0 ;
36075   float arg4 ;
36076   float arg5 ;
36077   bool result;
36078
36079   arg1 = (Dali::Actor *)jarg1;
36080   arg2 = (float *)jarg2;
36081   arg3 = (float *)jarg3;
36082   arg4 = (float)jarg4;
36083   arg5 = (float)jarg5;
36084   {
36085     try {
36086       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36087     } catch (std::out_of_range& e) {
36088       {
36089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36090       };
36091     } catch (std::exception& e) {
36092       {
36093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36094       };
36095     } catch (Dali::DaliException e) {
36096       {
36097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36098       };
36099     } catch (...) {
36100       {
36101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36102       };
36103     }
36104   }
36105
36106   jresult = result;
36107   return jresult;
36108 }
36109
36110
36111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36113   bool arg2 ;
36114
36115   arg1 = (Dali::Actor *)jarg1;
36116   arg2 = jarg2 ? true : false;
36117   {
36118     try {
36119       (arg1)->SetLeaveRequired(arg2);
36120     } catch (std::out_of_range& e) {
36121       {
36122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36123       };
36124     } catch (std::exception& e) {
36125       {
36126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36127       };
36128     } catch (Dali::DaliException e) {
36129       {
36130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36131       };
36132     } catch (...) {
36133       {
36134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36135       };
36136     }
36137   }
36138
36139 }
36140
36141
36142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36143   unsigned int jresult ;
36144   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36145   bool result;
36146
36147   arg1 = (Dali::Actor *)jarg1;
36148   {
36149     try {
36150       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36151     } catch (std::out_of_range& e) {
36152       {
36153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36154       };
36155     } catch (std::exception& e) {
36156       {
36157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36158       };
36159     } catch (Dali::DaliException e) {
36160       {
36161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36162       };
36163     } catch (...) {
36164       {
36165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36166       };
36167     }
36168   }
36169
36170   jresult = result;
36171   return jresult;
36172 }
36173
36174
36175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36176   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36177   bool arg2 ;
36178
36179   arg1 = (Dali::Actor *)jarg1;
36180   arg2 = jarg2 ? true : false;
36181   {
36182     try {
36183       (arg1)->SetKeyboardFocusable(arg2);
36184     } catch (std::out_of_range& e) {
36185       {
36186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36187       };
36188     } catch (std::exception& e) {
36189       {
36190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36191       };
36192     } catch (Dali::DaliException e) {
36193       {
36194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36195       };
36196     } catch (...) {
36197       {
36198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36199       };
36200     }
36201   }
36202
36203 }
36204
36205
36206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36207   unsigned int jresult ;
36208   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36209   bool result;
36210
36211   arg1 = (Dali::Actor *)jarg1;
36212   {
36213     try {
36214       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36215     } catch (std::out_of_range& e) {
36216       {
36217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36218       };
36219     } catch (std::exception& e) {
36220       {
36221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36222       };
36223     } catch (Dali::DaliException e) {
36224       {
36225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36226       };
36227     } catch (...) {
36228       {
36229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36230       };
36231     }
36232   }
36233
36234   jresult = result;
36235   return jresult;
36236 }
36237
36238
36239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36240   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36241   Dali::ResizePolicy::Type arg2 ;
36242   Dali::Dimension::Type arg3 ;
36243
36244   arg1 = (Dali::Actor *)jarg1;
36245   arg2 = (Dali::ResizePolicy::Type)jarg2;
36246   arg3 = (Dali::Dimension::Type)jarg3;
36247   {
36248     try {
36249       (arg1)->SetResizePolicy(arg2,arg3);
36250     } catch (std::out_of_range& e) {
36251       {
36252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36253       };
36254     } catch (std::exception& e) {
36255       {
36256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36257       };
36258     } catch (Dali::DaliException e) {
36259       {
36260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36261       };
36262     } catch (...) {
36263       {
36264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36265       };
36266     }
36267   }
36268
36269 }
36270
36271
36272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36273   int jresult ;
36274   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36275   Dali::Dimension::Type arg2 ;
36276   Dali::ResizePolicy::Type result;
36277
36278   arg1 = (Dali::Actor *)jarg1;
36279   arg2 = (Dali::Dimension::Type)jarg2;
36280   {
36281     try {
36282       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36283     } catch (std::out_of_range& e) {
36284       {
36285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36286       };
36287     } catch (std::exception& e) {
36288       {
36289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36290       };
36291     } catch (Dali::DaliException e) {
36292       {
36293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36294       };
36295     } catch (...) {
36296       {
36297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36298       };
36299     }
36300   }
36301
36302   jresult = (int)result;
36303   return jresult;
36304 }
36305
36306
36307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36308   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36309   Dali::SizeScalePolicy::Type arg2 ;
36310
36311   arg1 = (Dali::Actor *)jarg1;
36312   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36313   {
36314     try {
36315       (arg1)->SetSizeScalePolicy(arg2);
36316     } catch (std::out_of_range& e) {
36317       {
36318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36319       };
36320     } catch (std::exception& e) {
36321       {
36322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36323       };
36324     } catch (Dali::DaliException e) {
36325       {
36326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36327       };
36328     } catch (...) {
36329       {
36330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36331       };
36332     }
36333   }
36334
36335 }
36336
36337
36338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36339   int jresult ;
36340   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36341   Dali::SizeScalePolicy::Type result;
36342
36343   arg1 = (Dali::Actor *)jarg1;
36344   {
36345     try {
36346       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36347     } catch (std::out_of_range& e) {
36348       {
36349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36350       };
36351     } catch (std::exception& e) {
36352       {
36353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36354       };
36355     } catch (Dali::DaliException e) {
36356       {
36357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36358       };
36359     } catch (...) {
36360       {
36361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36362       };
36363     }
36364   }
36365
36366   jresult = (int)result;
36367   return jresult;
36368 }
36369
36370
36371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36372   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36373   Dali::Vector3 *arg2 = 0 ;
36374
36375   arg1 = (Dali::Actor *)jarg1;
36376   arg2 = (Dali::Vector3 *)jarg2;
36377   if (!arg2) {
36378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36379     return ;
36380   }
36381   {
36382     try {
36383       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36384     } catch (std::out_of_range& e) {
36385       {
36386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36387       };
36388     } catch (std::exception& e) {
36389       {
36390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36391       };
36392     } catch (Dali::DaliException e) {
36393       {
36394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36395       };
36396     } catch (...) {
36397       {
36398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36399       };
36400     }
36401   }
36402
36403 }
36404
36405
36406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36407   void * jresult ;
36408   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36409   Dali::Vector3 result;
36410
36411   arg1 = (Dali::Actor *)jarg1;
36412   {
36413     try {
36414       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36415     } catch (std::out_of_range& e) {
36416       {
36417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36418       };
36419     } catch (std::exception& e) {
36420       {
36421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36422       };
36423     } catch (Dali::DaliException e) {
36424       {
36425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36426       };
36427     } catch (...) {
36428       {
36429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36430       };
36431     }
36432   }
36433
36434   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36435   return jresult;
36436 }
36437
36438
36439 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36440   float jresult ;
36441   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36442   float arg2 ;
36443   float result;
36444
36445   arg1 = (Dali::Actor *)jarg1;
36446   arg2 = (float)jarg2;
36447   {
36448     try {
36449       result = (float)(arg1)->GetHeightForWidth(arg2);
36450     } catch (std::out_of_range& e) {
36451       {
36452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36453       };
36454     } catch (std::exception& e) {
36455       {
36456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36457       };
36458     } catch (Dali::DaliException e) {
36459       {
36460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36461       };
36462     } catch (...) {
36463       {
36464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36465       };
36466     }
36467   }
36468
36469   jresult = result;
36470   return jresult;
36471 }
36472
36473
36474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36475   float jresult ;
36476   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36477   float arg2 ;
36478   float result;
36479
36480   arg1 = (Dali::Actor *)jarg1;
36481   arg2 = (float)jarg2;
36482   {
36483     try {
36484       result = (float)(arg1)->GetWidthForHeight(arg2);
36485     } catch (std::out_of_range& e) {
36486       {
36487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36488       };
36489     } catch (std::exception& e) {
36490       {
36491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36492       };
36493     } catch (Dali::DaliException e) {
36494       {
36495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36496       };
36497     } catch (...) {
36498       {
36499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36500       };
36501     }
36502   }
36503
36504   jresult = result;
36505   return jresult;
36506 }
36507
36508
36509 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36510   float jresult ;
36511   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36512   Dali::Dimension::Type arg2 ;
36513   float result;
36514
36515   arg1 = (Dali::Actor *)jarg1;
36516   arg2 = (Dali::Dimension::Type)jarg2;
36517   {
36518     try {
36519       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36520     } catch (std::out_of_range& e) {
36521       {
36522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36523       };
36524     } catch (std::exception& e) {
36525       {
36526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36527       };
36528     } catch (Dali::DaliException e) {
36529       {
36530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36531       };
36532     } catch (...) {
36533       {
36534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36535       };
36536     }
36537   }
36538
36539   jresult = result;
36540   return jresult;
36541 }
36542
36543
36544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36545   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36546   Dali::Padding *arg2 = 0 ;
36547
36548   arg1 = (Dali::Actor *)jarg1;
36549   arg2 = (Dali::Padding *)jarg2;
36550   if (!arg2) {
36551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36552     return ;
36553   }
36554   {
36555     try {
36556       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36557     } catch (std::out_of_range& e) {
36558       {
36559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36560       };
36561     } catch (std::exception& e) {
36562       {
36563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36564       };
36565     } catch (Dali::DaliException e) {
36566       {
36567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36568       };
36569     } catch (...) {
36570       {
36571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36572       };
36573     }
36574   }
36575
36576 }
36577
36578
36579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36580   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36581   Dali::Padding *arg2 = 0 ;
36582
36583   arg1 = (Dali::Actor *)jarg1;
36584   arg2 = (Dali::Padding *)jarg2;
36585   if (!arg2) {
36586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36587     return ;
36588   }
36589   {
36590     try {
36591       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36592     } catch (std::out_of_range& e) {
36593       {
36594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36595       };
36596     } catch (std::exception& e) {
36597       {
36598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36599       };
36600     } catch (Dali::DaliException e) {
36601       {
36602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36603       };
36604     } catch (...) {
36605       {
36606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36607       };
36608     }
36609   }
36610
36611 }
36612
36613
36614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36615   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36616   Dali::Vector2 *arg2 = 0 ;
36617
36618   arg1 = (Dali::Actor *)jarg1;
36619   arg2 = (Dali::Vector2 *)jarg2;
36620   if (!arg2) {
36621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36622     return ;
36623   }
36624   {
36625     try {
36626       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36627     } catch (std::out_of_range& e) {
36628       {
36629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36630       };
36631     } catch (std::exception& e) {
36632       {
36633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36634       };
36635     } catch (Dali::DaliException e) {
36636       {
36637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36638       };
36639     } catch (...) {
36640       {
36641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36642       };
36643     }
36644   }
36645
36646 }
36647
36648
36649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36650   void * jresult ;
36651   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36652   Dali::Vector2 result;
36653
36654   arg1 = (Dali::Actor *)jarg1;
36655   {
36656     try {
36657       result = (arg1)->GetMinimumSize();
36658     } catch (std::out_of_range& e) {
36659       {
36660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36661       };
36662     } catch (std::exception& e) {
36663       {
36664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36665       };
36666     } catch (Dali::DaliException e) {
36667       {
36668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36669       };
36670     } catch (...) {
36671       {
36672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36673       };
36674     }
36675   }
36676
36677   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36678   return jresult;
36679 }
36680
36681
36682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36683   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36684   Dali::Vector2 *arg2 = 0 ;
36685
36686   arg1 = (Dali::Actor *)jarg1;
36687   arg2 = (Dali::Vector2 *)jarg2;
36688   if (!arg2) {
36689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36690     return ;
36691   }
36692   {
36693     try {
36694       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36695     } catch (std::out_of_range& e) {
36696       {
36697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36698       };
36699     } catch (std::exception& e) {
36700       {
36701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36702       };
36703     } catch (Dali::DaliException e) {
36704       {
36705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36706       };
36707     } catch (...) {
36708       {
36709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36710       };
36711     }
36712   }
36713
36714 }
36715
36716
36717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36718   void * jresult ;
36719   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36720   Dali::Vector2 result;
36721
36722   arg1 = (Dali::Actor *)jarg1;
36723   {
36724     try {
36725       result = (arg1)->GetMaximumSize();
36726     } catch (std::out_of_range& e) {
36727       {
36728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36729       };
36730     } catch (std::exception& e) {
36731       {
36732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36733       };
36734     } catch (Dali::DaliException e) {
36735       {
36736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36737       };
36738     } catch (...) {
36739       {
36740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36741       };
36742     }
36743   }
36744
36745   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36746   return jresult;
36747 }
36748
36749
36750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36751   int jresult ;
36752   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36753   int result;
36754
36755   arg1 = (Dali::Actor *)jarg1;
36756   {
36757     try {
36758       result = (int)(arg1)->GetHierarchyDepth();
36759       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36760     } catch (std::out_of_range& e) {
36761       {
36762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36763       };
36764     } catch (std::exception& e) {
36765       {
36766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36767       };
36768     } catch (Dali::DaliException e) {
36769       {
36770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36771       };
36772     } catch (...) {
36773       {
36774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36775       };
36776     }
36777   }
36778
36779   jresult = result;
36780   return jresult;
36781 }
36782
36783
36784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36785   unsigned int jresult ;
36786   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36787   Dali::Renderer *arg2 = 0 ;
36788   unsigned int result;
36789
36790   arg1 = (Dali::Actor *)jarg1;
36791   arg2 = (Dali::Renderer *)jarg2;
36792   if (!arg2) {
36793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36794     return 0;
36795   }
36796   {
36797     try {
36798       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36799     } catch (std::out_of_range& e) {
36800       {
36801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36802       };
36803     } catch (std::exception& e) {
36804       {
36805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36806       };
36807     } catch (Dali::DaliException e) {
36808       {
36809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36810       };
36811     } catch (...) {
36812       {
36813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36814       };
36815     }
36816   }
36817
36818   jresult = result;
36819   return jresult;
36820 }
36821
36822
36823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36824   unsigned int jresult ;
36825   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36826   unsigned int result;
36827
36828   arg1 = (Dali::Actor *)jarg1;
36829   {
36830     try {
36831       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36832     } catch (std::out_of_range& e) {
36833       {
36834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36835       };
36836     } catch (std::exception& e) {
36837       {
36838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36839       };
36840     } catch (Dali::DaliException e) {
36841       {
36842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36843       };
36844     } catch (...) {
36845       {
36846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36847       };
36848     }
36849   }
36850
36851   jresult = result;
36852   return jresult;
36853 }
36854
36855
36856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36857   void * jresult ;
36858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36859   unsigned int arg2 ;
36860   Dali::Renderer result;
36861
36862   arg1 = (Dali::Actor *)jarg1;
36863   arg2 = (unsigned int)jarg2;
36864   {
36865     try {
36866       result = (arg1)->GetRendererAt(arg2);
36867     } catch (std::out_of_range& e) {
36868       {
36869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36870       };
36871     } catch (std::exception& e) {
36872       {
36873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36874       };
36875     } catch (Dali::DaliException e) {
36876       {
36877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36878       };
36879     } catch (...) {
36880       {
36881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36882       };
36883     }
36884   }
36885
36886   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36887   return jresult;
36888 }
36889
36890
36891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36892   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36893   Dali::Renderer *arg2 = 0 ;
36894
36895   arg1 = (Dali::Actor *)jarg1;
36896   arg2 = (Dali::Renderer *)jarg2;
36897   if (!arg2) {
36898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36899     return ;
36900   }
36901   {
36902     try {
36903       (arg1)->RemoveRenderer(*arg2);
36904     } catch (std::out_of_range& e) {
36905       {
36906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36907       };
36908     } catch (std::exception& e) {
36909       {
36910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36911       };
36912     } catch (Dali::DaliException e) {
36913       {
36914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36915       };
36916     } catch (...) {
36917       {
36918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36919       };
36920     }
36921   }
36922
36923 }
36924
36925
36926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36927   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36928   unsigned int arg2 ;
36929
36930   arg1 = (Dali::Actor *)jarg1;
36931   arg2 = (unsigned int)jarg2;
36932   {
36933     try {
36934       (arg1)->RemoveRenderer(arg2);
36935     } catch (std::out_of_range& e) {
36936       {
36937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36938       };
36939     } catch (std::exception& e) {
36940       {
36941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36942       };
36943     } catch (Dali::DaliException e) {
36944       {
36945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36946       };
36947     } catch (...) {
36948       {
36949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36950       };
36951     }
36952   }
36953
36954 }
36955
36956
36957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36958   void * jresult ;
36959   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36960   Dali::Actor::TouchSignalType *result = 0 ;
36961
36962   arg1 = (Dali::Actor *)jarg1;
36963   {
36964     try {
36965       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36966     } catch (std::out_of_range& e) {
36967       {
36968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36969       };
36970     } catch (std::exception& e) {
36971       {
36972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36973       };
36974     } catch (Dali::DaliException e) {
36975       {
36976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36977       };
36978     } catch (...) {
36979       {
36980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36981       };
36982     }
36983   }
36984
36985   jresult = (void *)result;
36986   return jresult;
36987 }
36988
36989
36990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36991   void * jresult ;
36992   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36993   Dali::Actor::TouchDataSignalType *result = 0 ;
36994
36995   arg1 = (Dali::Actor *)jarg1;
36996   {
36997     try {
36998       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36999     } catch (std::out_of_range& e) {
37000       {
37001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37002       };
37003     } catch (std::exception& e) {
37004       {
37005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37006       };
37007     } catch (Dali::DaliException e) {
37008       {
37009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37010       };
37011     } catch (...) {
37012       {
37013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37014       };
37015     }
37016   }
37017
37018   jresult = (void *)result;
37019   return jresult;
37020 }
37021
37022
37023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
37024   void * jresult ;
37025   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37026   Dali::Actor::HoverSignalType *result = 0 ;
37027
37028   arg1 = (Dali::Actor *)jarg1;
37029   {
37030     try {
37031       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37032     } catch (std::out_of_range& e) {
37033       {
37034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37035       };
37036     } catch (std::exception& e) {
37037       {
37038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37039       };
37040     } catch (Dali::DaliException e) {
37041       {
37042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37043       };
37044     } catch (...) {
37045       {
37046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37047       };
37048     }
37049   }
37050
37051   jresult = (void *)result;
37052   return jresult;
37053 }
37054
37055
37056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37057   void * jresult ;
37058   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37059   Dali::Actor::WheelEventSignalType *result = 0 ;
37060
37061   arg1 = (Dali::Actor *)jarg1;
37062   {
37063     try {
37064       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37065     } catch (std::out_of_range& e) {
37066       {
37067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37068       };
37069     } catch (std::exception& e) {
37070       {
37071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37072       };
37073     } catch (Dali::DaliException e) {
37074       {
37075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37076       };
37077     } catch (...) {
37078       {
37079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37080       };
37081     }
37082   }
37083
37084   jresult = (void *)result;
37085   return jresult;
37086 }
37087
37088
37089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37090   void * jresult ;
37091   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37092   Dali::Actor::OnStageSignalType *result = 0 ;
37093
37094   arg1 = (Dali::Actor *)jarg1;
37095   {
37096     try {
37097       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37098     } catch (std::out_of_range& e) {
37099       {
37100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37101       };
37102     } catch (std::exception& e) {
37103       {
37104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37105       };
37106     } catch (Dali::DaliException e) {
37107       {
37108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37109       };
37110     } catch (...) {
37111       {
37112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37113       };
37114     }
37115   }
37116
37117   jresult = (void *)result;
37118   return jresult;
37119 }
37120
37121
37122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37123   void * jresult ;
37124   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37125   Dali::Actor::OffStageSignalType *result = 0 ;
37126
37127   arg1 = (Dali::Actor *)jarg1;
37128   {
37129     try {
37130       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37131     } catch (std::out_of_range& e) {
37132       {
37133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37134       };
37135     } catch (std::exception& e) {
37136       {
37137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37138       };
37139     } catch (Dali::DaliException e) {
37140       {
37141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37142       };
37143     } catch (...) {
37144       {
37145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37146       };
37147     }
37148   }
37149
37150   jresult = (void *)result;
37151   return jresult;
37152 }
37153
37154
37155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37156   void * jresult ;
37157   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37158   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37159
37160   arg1 = (Dali::Actor *)jarg1;
37161   {
37162     try {
37163       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37164     } catch (std::out_of_range& e) {
37165       {
37166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37167       };
37168     } catch (std::exception& e) {
37169       {
37170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37171       };
37172     } catch (Dali::DaliException e) {
37173       {
37174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37175       };
37176     } catch (...) {
37177       {
37178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37179       };
37180     }
37181   }
37182
37183   jresult = (void *)result;
37184   return jresult;
37185 }
37186
37187
37188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37189   Dali::Actor *arg1 = 0 ;
37190
37191   arg1 = (Dali::Actor *)jarg1;
37192   if (!arg1) {
37193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37194     return ;
37195   }
37196   {
37197     try {
37198       Dali::UnparentAndReset(*arg1);
37199     } catch (std::out_of_range& e) {
37200       {
37201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37202       };
37203     } catch (std::exception& e) {
37204       {
37205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37206       };
37207     } catch (Dali::DaliException e) {
37208       {
37209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37210       };
37211     } catch (...) {
37212       {
37213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37214       };
37215     }
37216   }
37217
37218 }
37219
37220
37221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37222   int jresult ;
37223   int result;
37224
37225   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37226   jresult = (int)result;
37227   return jresult;
37228 }
37229
37230
37231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37232   int jresult ;
37233   int result;
37234
37235   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37236   jresult = (int)result;
37237   return jresult;
37238 }
37239
37240
37241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37242   int jresult ;
37243   int result;
37244
37245   result = (int)Dali::Layer::Property::BEHAVIOR;
37246   jresult = (int)result;
37247   return jresult;
37248 }
37249
37250
37251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37252   void * jresult ;
37253   Dali::Layer::Property *result = 0 ;
37254
37255   {
37256     try {
37257       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37258     } catch (std::out_of_range& e) {
37259       {
37260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37261       };
37262     } catch (std::exception& e) {
37263       {
37264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37265       };
37266     } catch (Dali::DaliException e) {
37267       {
37268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37269       };
37270     } catch (...) {
37271       {
37272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37273       };
37274     }
37275   }
37276
37277   jresult = (void *)result;
37278   return jresult;
37279 }
37280
37281
37282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37283   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37284
37285   arg1 = (Dali::Layer::Property *)jarg1;
37286   {
37287     try {
37288       delete arg1;
37289     } catch (std::out_of_range& e) {
37290       {
37291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37292       };
37293     } catch (std::exception& e) {
37294       {
37295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37296       };
37297     } catch (Dali::DaliException e) {
37298       {
37299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37300       };
37301     } catch (...) {
37302       {
37303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37304       };
37305     }
37306   }
37307
37308 }
37309
37310
37311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37312   void * jresult ;
37313   Dali::Layer *result = 0 ;
37314
37315   {
37316     try {
37317       result = (Dali::Layer *)new Dali::Layer();
37318     } catch (std::out_of_range& e) {
37319       {
37320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37321       };
37322     } catch (std::exception& e) {
37323       {
37324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37325       };
37326     } catch (Dali::DaliException e) {
37327       {
37328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37329       };
37330     } catch (...) {
37331       {
37332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37333       };
37334     }
37335   }
37336
37337   jresult = (void *)result;
37338   return jresult;
37339 }
37340
37341
37342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37343   void * jresult ;
37344   Dali::Layer result;
37345
37346   {
37347     try {
37348       result = Dali::Layer::New();
37349     } catch (std::out_of_range& e) {
37350       {
37351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37352       };
37353     } catch (std::exception& e) {
37354       {
37355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37356       };
37357     } catch (Dali::DaliException e) {
37358       {
37359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37360       };
37361     } catch (...) {
37362       {
37363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37364       };
37365     }
37366   }
37367
37368   jresult = new Dali::Layer((const Dali::Layer &)result);
37369   return jresult;
37370 }
37371
37372
37373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37374   void * jresult ;
37375   Dali::BaseHandle arg1 ;
37376   Dali::BaseHandle *argp1 ;
37377   Dali::Layer result;
37378
37379   argp1 = (Dali::BaseHandle *)jarg1;
37380   if (!argp1) {
37381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37382     return 0;
37383   }
37384   arg1 = *argp1;
37385   {
37386     try {
37387       result = Dali::Layer::DownCast(arg1);
37388     } catch (std::out_of_range& e) {
37389       {
37390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37391       };
37392     } catch (std::exception& e) {
37393       {
37394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37395       };
37396     } catch (Dali::DaliException e) {
37397       {
37398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37399       };
37400     } catch (...) {
37401       {
37402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37403       };
37404     }
37405   }
37406
37407   jresult = new Dali::Layer((const Dali::Layer &)result);
37408   return jresult;
37409 }
37410
37411
37412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37413   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37414
37415   arg1 = (Dali::Layer *)jarg1;
37416   {
37417     try {
37418       delete arg1;
37419     } catch (std::out_of_range& e) {
37420       {
37421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37422       };
37423     } catch (std::exception& e) {
37424       {
37425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37426       };
37427     } catch (Dali::DaliException e) {
37428       {
37429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37430       };
37431     } catch (...) {
37432       {
37433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37434       };
37435     }
37436   }
37437
37438 }
37439
37440
37441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37442   void * jresult ;
37443   Dali::Layer *arg1 = 0 ;
37444   Dali::Layer *result = 0 ;
37445
37446   arg1 = (Dali::Layer *)jarg1;
37447   if (!arg1) {
37448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37449     return 0;
37450   }
37451   {
37452     try {
37453       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37454     } catch (std::out_of_range& e) {
37455       {
37456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37457       };
37458     } catch (std::exception& e) {
37459       {
37460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37461       };
37462     } catch (Dali::DaliException e) {
37463       {
37464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37465       };
37466     } catch (...) {
37467       {
37468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37469       };
37470     }
37471   }
37472
37473   jresult = (void *)result;
37474   return jresult;
37475 }
37476
37477
37478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37479   void * jresult ;
37480   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37481   Dali::Layer *arg2 = 0 ;
37482   Dali::Layer *result = 0 ;
37483
37484   arg1 = (Dali::Layer *)jarg1;
37485   arg2 = (Dali::Layer *)jarg2;
37486   if (!arg2) {
37487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37488     return 0;
37489   }
37490   {
37491     try {
37492       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37493     } catch (std::out_of_range& e) {
37494       {
37495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37496       };
37497     } catch (std::exception& e) {
37498       {
37499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37500       };
37501     } catch (Dali::DaliException e) {
37502       {
37503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37504       };
37505     } catch (...) {
37506       {
37507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37508       };
37509     }
37510   }
37511
37512   jresult = (void *)result;
37513   return jresult;
37514 }
37515
37516
37517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37518   unsigned int jresult ;
37519   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37520   unsigned int result;
37521
37522   arg1 = (Dali::Layer *)jarg1;
37523   {
37524     try {
37525       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37526     } catch (std::out_of_range& e) {
37527       {
37528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37529       };
37530     } catch (std::exception& e) {
37531       {
37532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37533       };
37534     } catch (Dali::DaliException e) {
37535       {
37536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37537       };
37538     } catch (...) {
37539       {
37540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37541       };
37542     }
37543   }
37544
37545   jresult = result;
37546   return jresult;
37547 }
37548
37549
37550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37551   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37552
37553   arg1 = (Dali::Layer *)jarg1;
37554   {
37555     try {
37556       (arg1)->Raise();
37557     } catch (std::out_of_range& e) {
37558       {
37559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37560       };
37561     } catch (std::exception& e) {
37562       {
37563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37564       };
37565     } catch (Dali::DaliException e) {
37566       {
37567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37568       };
37569     } catch (...) {
37570       {
37571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37572       };
37573     }
37574   }
37575
37576 }
37577
37578
37579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37580   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37581
37582   arg1 = (Dali::Layer *)jarg1;
37583   {
37584     try {
37585       (arg1)->Lower();
37586     } catch (std::out_of_range& e) {
37587       {
37588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37589       };
37590     } catch (std::exception& e) {
37591       {
37592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37593       };
37594     } catch (Dali::DaliException e) {
37595       {
37596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37597       };
37598     } catch (...) {
37599       {
37600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37601       };
37602     }
37603   }
37604
37605 }
37606
37607
37608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37609   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37610   Dali::Layer arg2 ;
37611   Dali::Layer *argp2 ;
37612
37613   arg1 = (Dali::Layer *)jarg1;
37614   argp2 = (Dali::Layer *)jarg2;
37615   if (!argp2) {
37616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37617     return ;
37618   }
37619   arg2 = *argp2;
37620   {
37621     try {
37622       (arg1)->RaiseAbove(arg2);
37623     } catch (std::out_of_range& e) {
37624       {
37625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37626       };
37627     } catch (std::exception& e) {
37628       {
37629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37630       };
37631     } catch (Dali::DaliException e) {
37632       {
37633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37634       };
37635     } catch (...) {
37636       {
37637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37638       };
37639     }
37640   }
37641
37642 }
37643
37644
37645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37646   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37647   Dali::Layer arg2 ;
37648   Dali::Layer *argp2 ;
37649
37650   arg1 = (Dali::Layer *)jarg1;
37651   argp2 = (Dali::Layer *)jarg2;
37652   if (!argp2) {
37653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37654     return ;
37655   }
37656   arg2 = *argp2;
37657   {
37658     try {
37659       (arg1)->LowerBelow(arg2);
37660     } catch (std::out_of_range& e) {
37661       {
37662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37663       };
37664     } catch (std::exception& e) {
37665       {
37666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37667       };
37668     } catch (Dali::DaliException e) {
37669       {
37670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37671       };
37672     } catch (...) {
37673       {
37674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37675       };
37676     }
37677   }
37678
37679 }
37680
37681
37682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37683   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37684
37685   arg1 = (Dali::Layer *)jarg1;
37686   {
37687     try {
37688       (arg1)->RaiseToTop();
37689     } catch (std::out_of_range& e) {
37690       {
37691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37692       };
37693     } catch (std::exception& e) {
37694       {
37695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37696       };
37697     } catch (Dali::DaliException e) {
37698       {
37699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37700       };
37701     } catch (...) {
37702       {
37703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37704       };
37705     }
37706   }
37707
37708 }
37709
37710
37711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37712   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37713
37714   arg1 = (Dali::Layer *)jarg1;
37715   {
37716     try {
37717       (arg1)->LowerToBottom();
37718     } catch (std::out_of_range& e) {
37719       {
37720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37721       };
37722     } catch (std::exception& e) {
37723       {
37724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37725       };
37726     } catch (Dali::DaliException e) {
37727       {
37728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37729       };
37730     } catch (...) {
37731       {
37732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37733       };
37734     }
37735   }
37736
37737 }
37738
37739
37740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37741   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37742   Dali::Layer arg2 ;
37743   Dali::Layer *argp2 ;
37744
37745   arg1 = (Dali::Layer *)jarg1;
37746   argp2 = (Dali::Layer *)jarg2;
37747   if (!argp2) {
37748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37749     return ;
37750   }
37751   arg2 = *argp2;
37752   {
37753     try {
37754       (arg1)->MoveAbove(arg2);
37755     } catch (std::out_of_range& e) {
37756       {
37757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37758       };
37759     } catch (std::exception& e) {
37760       {
37761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37762       };
37763     } catch (Dali::DaliException e) {
37764       {
37765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37766       };
37767     } catch (...) {
37768       {
37769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37770       };
37771     }
37772   }
37773
37774 }
37775
37776
37777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37778   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37779   Dali::Layer arg2 ;
37780   Dali::Layer *argp2 ;
37781
37782   arg1 = (Dali::Layer *)jarg1;
37783   argp2 = (Dali::Layer *)jarg2;
37784   if (!argp2) {
37785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37786     return ;
37787   }
37788   arg2 = *argp2;
37789   {
37790     try {
37791       (arg1)->MoveBelow(arg2);
37792     } catch (std::out_of_range& e) {
37793       {
37794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37795       };
37796     } catch (std::exception& e) {
37797       {
37798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37799       };
37800     } catch (Dali::DaliException e) {
37801       {
37802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37803       };
37804     } catch (...) {
37805       {
37806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37807       };
37808     }
37809   }
37810
37811 }
37812
37813
37814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37815   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37816   Dali::Layer::Behavior arg2 ;
37817
37818   arg1 = (Dali::Layer *)jarg1;
37819   arg2 = (Dali::Layer::Behavior)jarg2;
37820   {
37821     try {
37822       (arg1)->SetBehavior(arg2);
37823     } catch (std::out_of_range& e) {
37824       {
37825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37826       };
37827     } catch (std::exception& e) {
37828       {
37829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37830       };
37831     } catch (Dali::DaliException e) {
37832       {
37833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37834       };
37835     } catch (...) {
37836       {
37837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37838       };
37839     }
37840   }
37841
37842 }
37843
37844
37845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37846   int jresult ;
37847   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37848   Dali::Layer::Behavior result;
37849
37850   arg1 = (Dali::Layer *)jarg1;
37851   {
37852     try {
37853       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37854     } catch (std::out_of_range& e) {
37855       {
37856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37857       };
37858     } catch (std::exception& e) {
37859       {
37860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37861       };
37862     } catch (Dali::DaliException e) {
37863       {
37864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37865       };
37866     } catch (...) {
37867       {
37868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37869       };
37870     }
37871   }
37872
37873   jresult = (int)result;
37874   return jresult;
37875 }
37876
37877
37878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37879   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37880   bool arg2 ;
37881
37882   arg1 = (Dali::Layer *)jarg1;
37883   arg2 = jarg2 ? true : false;
37884   {
37885     try {
37886       (arg1)->SetClipping(arg2);
37887     } catch (std::out_of_range& e) {
37888       {
37889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37890       };
37891     } catch (std::exception& e) {
37892       {
37893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37894       };
37895     } catch (Dali::DaliException e) {
37896       {
37897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37898       };
37899     } catch (...) {
37900       {
37901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37902       };
37903     }
37904   }
37905
37906 }
37907
37908
37909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37910   unsigned int jresult ;
37911   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37912   bool result;
37913
37914   arg1 = (Dali::Layer *)jarg1;
37915   {
37916     try {
37917       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37918     } catch (std::out_of_range& e) {
37919       {
37920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37921       };
37922     } catch (std::exception& e) {
37923       {
37924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37925       };
37926     } catch (Dali::DaliException e) {
37927       {
37928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37929       };
37930     } catch (...) {
37931       {
37932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37933       };
37934     }
37935   }
37936
37937   jresult = result;
37938   return jresult;
37939 }
37940
37941
37942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37943   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37944   int arg2 ;
37945   int arg3 ;
37946   int arg4 ;
37947   int arg5 ;
37948
37949   arg1 = (Dali::Layer *)jarg1;
37950   arg2 = (int)jarg2;
37951   arg3 = (int)jarg3;
37952   arg4 = (int)jarg4;
37953   arg5 = (int)jarg5;
37954   {
37955     try {
37956       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37957     } catch (std::out_of_range& e) {
37958       {
37959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37960       };
37961     } catch (std::exception& e) {
37962       {
37963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37964       };
37965     } catch (Dali::DaliException e) {
37966       {
37967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37968       };
37969     } catch (...) {
37970       {
37971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37972       };
37973     }
37974   }
37975
37976 }
37977
37978
37979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37980   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37981   Dali::ClippingBox arg2 ;
37982   Dali::ClippingBox *argp2 ;
37983
37984   arg1 = (Dali::Layer *)jarg1;
37985   argp2 = (Dali::ClippingBox *)jarg2;
37986   if (!argp2) {
37987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37988     return ;
37989   }
37990   arg2 = *argp2;
37991   {
37992     try {
37993       (arg1)->SetClippingBox(arg2);
37994     } catch (std::out_of_range& e) {
37995       {
37996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37997       };
37998     } catch (std::exception& e) {
37999       {
38000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38001       };
38002     } catch (Dali::DaliException e) {
38003       {
38004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38005       };
38006     } catch (...) {
38007       {
38008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38009       };
38010     }
38011   }
38012
38013 }
38014
38015
38016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
38017   void * jresult ;
38018   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38019   Dali::ClippingBox result;
38020
38021   arg1 = (Dali::Layer *)jarg1;
38022   {
38023     try {
38024       result = ((Dali::Layer const *)arg1)->GetClippingBox();
38025     } catch (std::out_of_range& e) {
38026       {
38027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38028       };
38029     } catch (std::exception& e) {
38030       {
38031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38032       };
38033     } catch (Dali::DaliException e) {
38034       {
38035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38036       };
38037     } catch (...) {
38038       {
38039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38040       };
38041     }
38042   }
38043
38044   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38045   return jresult;
38046 }
38047
38048
38049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38050   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38051   bool arg2 ;
38052
38053   arg1 = (Dali::Layer *)jarg1;
38054   arg2 = jarg2 ? true : false;
38055   {
38056     try {
38057       (arg1)->SetDepthTestDisabled(arg2);
38058     } catch (std::out_of_range& e) {
38059       {
38060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38061       };
38062     } catch (std::exception& e) {
38063       {
38064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38065       };
38066     } catch (Dali::DaliException e) {
38067       {
38068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38069       };
38070     } catch (...) {
38071       {
38072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38073       };
38074     }
38075   }
38076
38077 }
38078
38079
38080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38081   unsigned int jresult ;
38082   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38083   bool result;
38084
38085   arg1 = (Dali::Layer *)jarg1;
38086   {
38087     try {
38088       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38089     } catch (std::out_of_range& e) {
38090       {
38091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38092       };
38093     } catch (std::exception& e) {
38094       {
38095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38096       };
38097     } catch (Dali::DaliException e) {
38098       {
38099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38100       };
38101     } catch (...) {
38102       {
38103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38104       };
38105     }
38106   }
38107
38108   jresult = result;
38109   return jresult;
38110 }
38111
38112
38113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38114   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38115   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38116
38117   arg1 = (Dali::Layer *)jarg1;
38118   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38119   {
38120     try {
38121       (arg1)->SetSortFunction(arg2);
38122     } catch (std::out_of_range& e) {
38123       {
38124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38125       };
38126     } catch (std::exception& e) {
38127       {
38128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38129       };
38130     } catch (Dali::DaliException e) {
38131       {
38132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38133       };
38134     } catch (...) {
38135       {
38136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38137       };
38138     }
38139   }
38140
38141 }
38142
38143
38144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38145   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38146   bool arg2 ;
38147
38148   arg1 = (Dali::Layer *)jarg1;
38149   arg2 = jarg2 ? true : false;
38150   {
38151     try {
38152       (arg1)->SetTouchConsumed(arg2);
38153     } catch (std::out_of_range& e) {
38154       {
38155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38156       };
38157     } catch (std::exception& e) {
38158       {
38159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38160       };
38161     } catch (Dali::DaliException e) {
38162       {
38163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38164       };
38165     } catch (...) {
38166       {
38167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38168       };
38169     }
38170   }
38171
38172 }
38173
38174
38175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38176   unsigned int jresult ;
38177   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38178   bool result;
38179
38180   arg1 = (Dali::Layer *)jarg1;
38181   {
38182     try {
38183       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38184     } catch (std::out_of_range& e) {
38185       {
38186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38187       };
38188     } catch (std::exception& e) {
38189       {
38190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38191       };
38192     } catch (Dali::DaliException e) {
38193       {
38194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38195       };
38196     } catch (...) {
38197       {
38198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38199       };
38200     }
38201   }
38202
38203   jresult = result;
38204   return jresult;
38205 }
38206
38207
38208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38209   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38210   bool arg2 ;
38211
38212   arg1 = (Dali::Layer *)jarg1;
38213   arg2 = jarg2 ? true : false;
38214   {
38215     try {
38216       (arg1)->SetHoverConsumed(arg2);
38217     } catch (std::out_of_range& e) {
38218       {
38219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38220       };
38221     } catch (std::exception& e) {
38222       {
38223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38224       };
38225     } catch (Dali::DaliException e) {
38226       {
38227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38228       };
38229     } catch (...) {
38230       {
38231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38232       };
38233     }
38234   }
38235
38236 }
38237
38238
38239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38240   unsigned int jresult ;
38241   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38242   bool result;
38243
38244   arg1 = (Dali::Layer *)jarg1;
38245   {
38246     try {
38247       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38248     } catch (std::out_of_range& e) {
38249       {
38250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38251       };
38252     } catch (std::exception& e) {
38253       {
38254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38255       };
38256     } catch (Dali::DaliException e) {
38257       {
38258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38259       };
38260     } catch (...) {
38261       {
38262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38263       };
38264     }
38265   }
38266
38267   jresult = result;
38268   return jresult;
38269 }
38270
38271
38272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38273   void * jresult ;
38274   Dali::Vector4 *result = 0 ;
38275
38276   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38277   jresult = (void *)result;
38278   return jresult;
38279 }
38280
38281
38282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38283   void * jresult ;
38284   Dali::Vector4 *result = 0 ;
38285
38286   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38287   jresult = (void *)result;
38288   return jresult;
38289 }
38290
38291
38292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38293   void * jresult ;
38294   Dali::Stage *result = 0 ;
38295
38296   {
38297     try {
38298       result = (Dali::Stage *)new Dali::Stage();
38299     } catch (std::out_of_range& e) {
38300       {
38301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38302       };
38303     } catch (std::exception& e) {
38304       {
38305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38306       };
38307     } catch (Dali::DaliException e) {
38308       {
38309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38310       };
38311     } catch (...) {
38312       {
38313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38314       };
38315     }
38316   }
38317
38318   jresult = (void *)result;
38319   return jresult;
38320 }
38321
38322
38323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38324   void * jresult ;
38325   Dali::Stage result;
38326
38327   {
38328     try {
38329       result = Dali::Stage::GetCurrent();
38330     } catch (std::out_of_range& e) {
38331       {
38332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38333       };
38334     } catch (std::exception& e) {
38335       {
38336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38337       };
38338     } catch (Dali::DaliException e) {
38339       {
38340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38341       };
38342     } catch (...) {
38343       {
38344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38345       };
38346     }
38347   }
38348
38349   jresult = new Dali::Stage((const Dali::Stage &)result);
38350   return jresult;
38351 }
38352
38353
38354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38355   unsigned int jresult ;
38356   bool result;
38357
38358   {
38359     try {
38360       result = (bool)Dali::Stage::IsInstalled();
38361     } catch (std::out_of_range& e) {
38362       {
38363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38364       };
38365     } catch (std::exception& e) {
38366       {
38367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38368       };
38369     } catch (Dali::DaliException e) {
38370       {
38371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38372       };
38373     } catch (...) {
38374       {
38375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38376       };
38377     }
38378   }
38379
38380   jresult = result;
38381   return jresult;
38382 }
38383
38384
38385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38386   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38387
38388   arg1 = (Dali::Stage *)jarg1;
38389   {
38390     try {
38391       delete arg1;
38392     } catch (std::out_of_range& e) {
38393       {
38394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38395       };
38396     } catch (std::exception& e) {
38397       {
38398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38399       };
38400     } catch (Dali::DaliException e) {
38401       {
38402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38403       };
38404     } catch (...) {
38405       {
38406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38407       };
38408     }
38409   }
38410
38411 }
38412
38413
38414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38415   void * jresult ;
38416   Dali::Stage *arg1 = 0 ;
38417   Dali::Stage *result = 0 ;
38418
38419   arg1 = (Dali::Stage *)jarg1;
38420   if (!arg1) {
38421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38422     return 0;
38423   }
38424   {
38425     try {
38426       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38427     } catch (std::out_of_range& e) {
38428       {
38429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38430       };
38431     } catch (std::exception& e) {
38432       {
38433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38434       };
38435     } catch (Dali::DaliException e) {
38436       {
38437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38438       };
38439     } catch (...) {
38440       {
38441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38442       };
38443     }
38444   }
38445
38446   jresult = (void *)result;
38447   return jresult;
38448 }
38449
38450
38451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38452   void * jresult ;
38453   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38454   Dali::Stage *arg2 = 0 ;
38455   Dali::Stage *result = 0 ;
38456
38457   arg1 = (Dali::Stage *)jarg1;
38458   arg2 = (Dali::Stage *)jarg2;
38459   if (!arg2) {
38460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38461     return 0;
38462   }
38463   {
38464     try {
38465       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38466     } catch (std::out_of_range& e) {
38467       {
38468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38469       };
38470     } catch (std::exception& e) {
38471       {
38472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38473       };
38474     } catch (Dali::DaliException e) {
38475       {
38476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38477       };
38478     } catch (...) {
38479       {
38480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38481       };
38482     }
38483   }
38484
38485   jresult = (void *)result;
38486   return jresult;
38487 }
38488
38489
38490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38491   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38492   Dali::Actor *arg2 = 0 ;
38493
38494   arg1 = (Dali::Stage *)jarg1;
38495   arg2 = (Dali::Actor *)jarg2;
38496   if (!arg2) {
38497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38498     return ;
38499   }
38500   {
38501     try {
38502       (arg1)->Add(*arg2);
38503     } catch (std::out_of_range& e) {
38504       {
38505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38506       };
38507     } catch (std::exception& e) {
38508       {
38509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38510       };
38511     } catch (Dali::DaliException e) {
38512       {
38513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38514       };
38515     } catch (...) {
38516       {
38517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38518       };
38519     }
38520   }
38521
38522 }
38523
38524
38525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38526   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38527   Dali::Actor *arg2 = 0 ;
38528
38529   arg1 = (Dali::Stage *)jarg1;
38530   arg2 = (Dali::Actor *)jarg2;
38531   if (!arg2) {
38532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38533     return ;
38534   }
38535   {
38536     try {
38537       (arg1)->Remove(*arg2);
38538     } catch (std::out_of_range& e) {
38539       {
38540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38541       };
38542     } catch (std::exception& e) {
38543       {
38544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38545       };
38546     } catch (Dali::DaliException e) {
38547       {
38548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38549       };
38550     } catch (...) {
38551       {
38552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38553       };
38554     }
38555   }
38556
38557 }
38558
38559
38560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38561   void * jresult ;
38562   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38563   Dali::Vector2 result;
38564
38565   arg1 = (Dali::Stage *)jarg1;
38566   {
38567     try {
38568       result = ((Dali::Stage const *)arg1)->GetSize();
38569     } catch (std::out_of_range& e) {
38570       {
38571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38572       };
38573     } catch (std::exception& e) {
38574       {
38575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38576       };
38577     } catch (Dali::DaliException e) {
38578       {
38579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38580       };
38581     } catch (...) {
38582       {
38583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38584       };
38585     }
38586   }
38587
38588   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38589   return jresult;
38590 }
38591
38592
38593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38594   void * jresult ;
38595   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38596   Dali::RenderTaskList result;
38597
38598   arg1 = (Dali::Stage *)jarg1;
38599   {
38600     try {
38601       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38602     } catch (std::out_of_range& e) {
38603       {
38604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38605       };
38606     } catch (std::exception& e) {
38607       {
38608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38609       };
38610     } catch (Dali::DaliException e) {
38611       {
38612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38613       };
38614     } catch (...) {
38615       {
38616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38617       };
38618     }
38619   }
38620
38621   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38622   return jresult;
38623 }
38624
38625
38626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38627   unsigned int jresult ;
38628   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38629   unsigned int result;
38630
38631   arg1 = (Dali::Stage *)jarg1;
38632   {
38633     try {
38634       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38635     } catch (std::out_of_range& e) {
38636       {
38637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38638       };
38639     } catch (std::exception& e) {
38640       {
38641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38642       };
38643     } catch (Dali::DaliException e) {
38644       {
38645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38646       };
38647     } catch (...) {
38648       {
38649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38650       };
38651     }
38652   }
38653
38654   jresult = result;
38655   return jresult;
38656 }
38657
38658
38659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38660   void * jresult ;
38661   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38662   unsigned int arg2 ;
38663   Dali::Layer result;
38664
38665   arg1 = (Dali::Stage *)jarg1;
38666   arg2 = (unsigned int)jarg2;
38667   {
38668     try {
38669       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38670     } catch (std::out_of_range& e) {
38671       {
38672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38673       };
38674     } catch (std::exception& e) {
38675       {
38676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38677       };
38678     } catch (Dali::DaliException e) {
38679       {
38680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38681       };
38682     } catch (...) {
38683       {
38684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38685       };
38686     }
38687   }
38688
38689   jresult = new Dali::Layer((const Dali::Layer &)result);
38690   return jresult;
38691 }
38692
38693
38694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38695   void * jresult ;
38696   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38697   Dali::Layer result;
38698
38699   arg1 = (Dali::Stage *)jarg1;
38700   {
38701     try {
38702       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38703     } catch (std::out_of_range& e) {
38704       {
38705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38706       };
38707     } catch (std::exception& e) {
38708       {
38709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38710       };
38711     } catch (Dali::DaliException e) {
38712       {
38713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38714       };
38715     } catch (...) {
38716       {
38717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38718       };
38719     }
38720   }
38721
38722   jresult = new Dali::Layer((const Dali::Layer &)result);
38723   return jresult;
38724 }
38725
38726
38727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38728   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38729   Dali::Vector4 arg2 ;
38730   Dali::Vector4 *argp2 ;
38731
38732   arg1 = (Dali::Stage *)jarg1;
38733   argp2 = (Dali::Vector4 *)jarg2;
38734   if (!argp2) {
38735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38736     return ;
38737   }
38738   arg2 = *argp2;
38739   {
38740     try {
38741       (arg1)->SetBackgroundColor(arg2);
38742     } catch (std::out_of_range& e) {
38743       {
38744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38745       };
38746     } catch (std::exception& e) {
38747       {
38748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38749       };
38750     } catch (Dali::DaliException e) {
38751       {
38752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38753       };
38754     } catch (...) {
38755       {
38756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38757       };
38758     }
38759   }
38760
38761 }
38762
38763
38764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38765   void * jresult ;
38766   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38767   Dali::Vector4 result;
38768
38769   arg1 = (Dali::Stage *)jarg1;
38770   {
38771     try {
38772       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38773     } catch (std::out_of_range& e) {
38774       {
38775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38776       };
38777     } catch (std::exception& e) {
38778       {
38779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38780       };
38781     } catch (Dali::DaliException e) {
38782       {
38783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38784       };
38785     } catch (...) {
38786       {
38787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38788       };
38789     }
38790   }
38791
38792   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38793   return jresult;
38794 }
38795
38796
38797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38798   void * jresult ;
38799   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38800   Dali::Vector2 result;
38801
38802   arg1 = (Dali::Stage *)jarg1;
38803   {
38804     try {
38805       result = ((Dali::Stage const *)arg1)->GetDpi();
38806     } catch (std::out_of_range& e) {
38807       {
38808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38809       };
38810     } catch (std::exception& e) {
38811       {
38812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38813       };
38814     } catch (Dali::DaliException e) {
38815       {
38816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38817       };
38818     } catch (...) {
38819       {
38820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38821       };
38822     }
38823   }
38824
38825   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38826   return jresult;
38827 }
38828
38829
38830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38831   void * jresult ;
38832   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38833   Dali::ObjectRegistry result;
38834
38835   arg1 = (Dali::Stage *)jarg1;
38836   {
38837     try {
38838       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38839     } catch (std::out_of_range& e) {
38840       {
38841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38842       };
38843     } catch (std::exception& e) {
38844       {
38845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38846       };
38847     } catch (Dali::DaliException e) {
38848       {
38849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38850       };
38851     } catch (...) {
38852       {
38853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38854       };
38855     }
38856   }
38857
38858   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38859   return jresult;
38860 }
38861
38862
38863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38864   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38865   float arg2 ;
38866
38867   arg1 = (Dali::Stage *)jarg1;
38868   arg2 = (float)jarg2;
38869   {
38870     try {
38871       (arg1)->KeepRendering(arg2);
38872     } catch (std::out_of_range& e) {
38873       {
38874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38875       };
38876     } catch (std::exception& e) {
38877       {
38878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38879       };
38880     } catch (Dali::DaliException e) {
38881       {
38882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38883       };
38884     } catch (...) {
38885       {
38886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38887       };
38888     }
38889   }
38890
38891 }
38892
38893
38894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38895   void * jresult ;
38896   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38897   Dali::Stage::KeyEventSignalType *result = 0 ;
38898
38899   arg1 = (Dali::Stage *)jarg1;
38900   {
38901     try {
38902       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38903     } catch (std::out_of_range& e) {
38904       {
38905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38906       };
38907     } catch (std::exception& e) {
38908       {
38909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38910       };
38911     } catch (Dali::DaliException e) {
38912       {
38913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38914       };
38915     } catch (...) {
38916       {
38917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38918       };
38919     }
38920   }
38921
38922   jresult = (void *)result;
38923   return jresult;
38924 }
38925
38926
38927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38928   void * jresult ;
38929   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38930   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38931
38932   arg1 = (Dali::Stage *)jarg1;
38933   {
38934     try {
38935       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38936     } catch (std::out_of_range& e) {
38937       {
38938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38939       };
38940     } catch (std::exception& e) {
38941       {
38942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38943       };
38944     } catch (Dali::DaliException e) {
38945       {
38946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38947       };
38948     } catch (...) {
38949       {
38950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38951       };
38952     }
38953   }
38954
38955   jresult = (void *)result;
38956   return jresult;
38957 }
38958
38959
38960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38961   void * jresult ;
38962   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38963   Dali::Stage::TouchSignalType *result = 0 ;
38964
38965   arg1 = (Dali::Stage *)jarg1;
38966   {
38967     try {
38968       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38969     } catch (std::out_of_range& e) {
38970       {
38971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38972       };
38973     } catch (std::exception& e) {
38974       {
38975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38976       };
38977     } catch (Dali::DaliException e) {
38978       {
38979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38980       };
38981     } catch (...) {
38982       {
38983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38984       };
38985     }
38986   }
38987
38988   jresult = (void *)result;
38989   return jresult;
38990 }
38991
38992
38993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38994   void * jresult ;
38995   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38996   Dali::Stage::WheelEventSignalType *result = 0 ;
38997
38998   arg1 = (Dali::Stage *)jarg1;
38999   {
39000     try {
39001       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
39002     } catch (std::out_of_range& e) {
39003       {
39004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39005       };
39006     } catch (std::exception& e) {
39007       {
39008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39009       };
39010     } catch (Dali::DaliException e) {
39011       {
39012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39013       };
39014     } catch (...) {
39015       {
39016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39017       };
39018     }
39019   }
39020
39021   jresult = (void *)result;
39022   return jresult;
39023 }
39024
39025
39026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
39027   void * jresult ;
39028   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39029   Dali::Stage::ContextStatusSignal *result = 0 ;
39030
39031   arg1 = (Dali::Stage *)jarg1;
39032   {
39033     try {
39034       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
39035     } catch (std::out_of_range& e) {
39036       {
39037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39038       };
39039     } catch (std::exception& e) {
39040       {
39041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39042       };
39043     } catch (Dali::DaliException e) {
39044       {
39045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39046       };
39047     } catch (...) {
39048       {
39049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39050       };
39051     }
39052   }
39053
39054   jresult = (void *)result;
39055   return jresult;
39056 }
39057
39058
39059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39060   void * jresult ;
39061   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39062   Dali::Stage::ContextStatusSignal *result = 0 ;
39063
39064   arg1 = (Dali::Stage *)jarg1;
39065   {
39066     try {
39067       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39068     } catch (std::out_of_range& e) {
39069       {
39070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39071       };
39072     } catch (std::exception& e) {
39073       {
39074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39075       };
39076     } catch (Dali::DaliException e) {
39077       {
39078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39079       };
39080     } catch (...) {
39081       {
39082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39083       };
39084     }
39085   }
39086
39087   jresult = (void *)result;
39088   return jresult;
39089 }
39090
39091
39092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39093   void * jresult ;
39094   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39095   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39096
39097   arg1 = (Dali::Stage *)jarg1;
39098   {
39099     try {
39100       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39101     } catch (std::out_of_range& e) {
39102       {
39103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39104       };
39105     } catch (std::exception& e) {
39106       {
39107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39108       };
39109     } catch (Dali::DaliException e) {
39110       {
39111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39112       };
39113     } catch (...) {
39114       {
39115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39116       };
39117     }
39118   }
39119
39120   jresult = (void *)result;
39121   return jresult;
39122 }
39123
39124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39125   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39126   Dali::DevelStage::Rendering arg2 ;
39127
39128   arg1 = (Dali::Stage *)jarg1;
39129   arg2 = (Dali::DevelStage::Rendering)jarg2;
39130   {
39131     try {
39132       DevelStage::SetRenderingBehavior(*arg1,arg2);
39133     } catch (std::out_of_range& e) {
39134       {
39135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39136       };
39137     } catch (std::exception& e) {
39138       {
39139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39140       };
39141     } catch (Dali::DaliException e) {
39142       {
39143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39144       };
39145     } catch (...) {
39146       {
39147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39148       };
39149     }
39150   }
39151
39152 }
39153
39154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39155
39156   int jresult ;
39157   int result ;
39158   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39159
39160   arg1 = (Dali::Stage *)jarg1;
39161   {
39162     try {
39163       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39164     } catch (std::out_of_range& e) {
39165       {
39166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39167       };
39168     } catch (std::exception& e) {
39169       {
39170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39171       };
39172     } catch (Dali::DaliException e) {
39173       {
39174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39175       };
39176     } catch (...) {
39177       {
39178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39179       };
39180     }
39181   }
39182
39183   jresult = result;
39184   return jresult;
39185 }
39186
39187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39188   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39189
39190   arg1 = (Dali::RelayoutContainer *)jarg1;
39191   {
39192     try {
39193       delete arg1;
39194     } catch (std::out_of_range& e) {
39195       {
39196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39197       };
39198     } catch (std::exception& e) {
39199       {
39200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39201       };
39202     } catch (Dali::DaliException e) {
39203       {
39204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39205       };
39206     } catch (...) {
39207       {
39208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39209       };
39210     }
39211   }
39212
39213 }
39214
39215
39216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39217   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39218   Dali::Actor *arg2 = 0 ;
39219   Dali::Vector2 *arg3 = 0 ;
39220
39221   arg1 = (Dali::RelayoutContainer *)jarg1;
39222   arg2 = (Dali::Actor *)jarg2;
39223   if (!arg2) {
39224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39225     return ;
39226   }
39227   arg3 = (Dali::Vector2 *)jarg3;
39228   if (!arg3) {
39229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39230     return ;
39231   }
39232   {
39233     try {
39234       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39235     } catch (std::out_of_range& e) {
39236       {
39237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39238       };
39239     } catch (std::exception& e) {
39240       {
39241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39242       };
39243     } catch (Dali::DaliException e) {
39244       {
39245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39246       };
39247     } catch (...) {
39248       {
39249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39250       };
39251     }
39252   }
39253
39254 }
39255
39256
39257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39258   void * jresult ;
39259   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39260   Dali::CustomActor result;
39261
39262   arg1 = (Dali::CustomActorImpl *)jarg1;
39263   {
39264     try {
39265       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39266     } catch (std::out_of_range& e) {
39267       {
39268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39269       };
39270     } catch (std::exception& e) {
39271       {
39272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39273       };
39274     } catch (Dali::DaliException e) {
39275       {
39276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39277       };
39278     } catch (...) {
39279       {
39280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39281       };
39282     }
39283   }
39284
39285   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39286   return jresult;
39287 }
39288
39289
39290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39291   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39292   int arg2 ;
39293
39294   arg1 = (Dali::CustomActorImpl *)jarg1;
39295   arg2 = (int)jarg2;
39296   {
39297     try {
39298       (arg1)->OnStageConnection(arg2);
39299     } catch (std::out_of_range& e) {
39300       {
39301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39302       };
39303     } catch (std::exception& e) {
39304       {
39305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39306       };
39307     } catch (Dali::DaliException e) {
39308       {
39309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39310       };
39311     } catch (...) {
39312       {
39313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39314       };
39315     }
39316   }
39317
39318 }
39319
39320
39321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39322   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39323
39324   arg1 = (Dali::CustomActorImpl *)jarg1;
39325   {
39326     try {
39327       (arg1)->OnStageDisconnection();
39328     } catch (std::out_of_range& e) {
39329       {
39330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39331       };
39332     } catch (std::exception& e) {
39333       {
39334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39335       };
39336     } catch (Dali::DaliException e) {
39337       {
39338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39339       };
39340     } catch (...) {
39341       {
39342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39343       };
39344     }
39345   }
39346
39347 }
39348
39349
39350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39351   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39352   Dali::Actor *arg2 = 0 ;
39353
39354   arg1 = (Dali::CustomActorImpl *)jarg1;
39355   arg2 = (Dali::Actor *)jarg2;
39356   if (!arg2) {
39357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39358     return ;
39359   }
39360   {
39361     try {
39362       (arg1)->OnChildAdd(*arg2);
39363     } catch (std::out_of_range& e) {
39364       {
39365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39366       };
39367     } catch (std::exception& e) {
39368       {
39369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39370       };
39371     } catch (Dali::DaliException e) {
39372       {
39373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39374       };
39375     } catch (...) {
39376       {
39377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39378       };
39379     }
39380   }
39381
39382 }
39383
39384
39385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39386   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39387   Dali::Actor *arg2 = 0 ;
39388
39389   arg1 = (Dali::CustomActorImpl *)jarg1;
39390   arg2 = (Dali::Actor *)jarg2;
39391   if (!arg2) {
39392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39393     return ;
39394   }
39395   {
39396     try {
39397       (arg1)->OnChildRemove(*arg2);
39398     } catch (std::out_of_range& e) {
39399       {
39400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39401       };
39402     } catch (std::exception& e) {
39403       {
39404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39405       };
39406     } catch (Dali::DaliException e) {
39407       {
39408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39409       };
39410     } catch (...) {
39411       {
39412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39413       };
39414     }
39415   }
39416
39417 }
39418
39419
39420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39421   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39422   Dali::Property::Index arg2 ;
39423   Dali::Property::Value arg3 ;
39424   Dali::Property::Value *argp3 ;
39425
39426   arg1 = (Dali::CustomActorImpl *)jarg1;
39427   arg2 = (Dali::Property::Index)jarg2;
39428   argp3 = (Dali::Property::Value *)jarg3;
39429   if (!argp3) {
39430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39431     return ;
39432   }
39433   arg3 = *argp3;
39434   {
39435     try {
39436       (arg1)->OnPropertySet(arg2,arg3);
39437     } catch (std::out_of_range& e) {
39438       {
39439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39440       };
39441     } catch (std::exception& e) {
39442       {
39443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39444       };
39445     } catch (Dali::DaliException e) {
39446       {
39447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39448       };
39449     } catch (...) {
39450       {
39451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39452       };
39453     }
39454   }
39455
39456 }
39457
39458
39459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39460   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39461   Dali::Vector3 *arg2 = 0 ;
39462
39463   arg1 = (Dali::CustomActorImpl *)jarg1;
39464   arg2 = (Dali::Vector3 *)jarg2;
39465   if (!arg2) {
39466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39467     return ;
39468   }
39469   {
39470     try {
39471       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39472     } catch (std::out_of_range& e) {
39473       {
39474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39475       };
39476     } catch (std::exception& e) {
39477       {
39478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39479       };
39480     } catch (Dali::DaliException e) {
39481       {
39482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39483       };
39484     } catch (...) {
39485       {
39486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39487       };
39488     }
39489   }
39490
39491 }
39492
39493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39494   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39495   Dali::Animation *arg2 = 0 ;
39496   Dali::Vector3 *arg3 = 0 ;
39497
39498   arg1 = (Dali::CustomActorImpl *)jarg1;
39499   arg2 = (Dali::Animation *)jarg2;
39500   if (!arg2) {
39501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39502     return ;
39503   }
39504   arg3 = (Dali::Vector3 *)jarg3;
39505   if (!arg3) {
39506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39507     return ;
39508   }
39509   {
39510     try {
39511       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39512     } catch (std::out_of_range& e) {
39513       {
39514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39515       };
39516     } catch (std::exception& e) {
39517       {
39518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39519       };
39520     } catch (Dali::DaliException e) {
39521       {
39522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39523       };
39524     } catch (...) {
39525       {
39526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39527       };
39528     }
39529   }
39530
39531 }
39532
39533
39534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39535   unsigned int jresult ;
39536   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39537   Dali::TouchEvent *arg2 = 0 ;
39538   bool result;
39539
39540   arg1 = (Dali::CustomActorImpl *)jarg1;
39541   arg2 = (Dali::TouchEvent *)jarg2;
39542   if (!arg2) {
39543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39544     return 0;
39545   }
39546   {
39547     try {
39548       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39549     } catch (std::out_of_range& e) {
39550       {
39551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39552       };
39553     } catch (std::exception& e) {
39554       {
39555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39556       };
39557     } catch (Dali::DaliException e) {
39558       {
39559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39560       };
39561     } catch (...) {
39562       {
39563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39564       };
39565     }
39566   }
39567
39568   jresult = result;
39569   return jresult;
39570 }
39571
39572
39573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39574   unsigned int jresult ;
39575   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39576   Dali::HoverEvent *arg2 = 0 ;
39577   bool result;
39578
39579   arg1 = (Dali::CustomActorImpl *)jarg1;
39580   arg2 = (Dali::HoverEvent *)jarg2;
39581   if (!arg2) {
39582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39583     return 0;
39584   }
39585   {
39586     try {
39587       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39588     } catch (std::out_of_range& e) {
39589       {
39590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39591       };
39592     } catch (std::exception& e) {
39593       {
39594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39595       };
39596     } catch (Dali::DaliException e) {
39597       {
39598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39599       };
39600     } catch (...) {
39601       {
39602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39603       };
39604     }
39605   }
39606
39607   jresult = result;
39608   return jresult;
39609 }
39610
39611
39612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39613   unsigned int jresult ;
39614   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39615   Dali::KeyEvent *arg2 = 0 ;
39616   bool result;
39617
39618   arg1 = (Dali::CustomActorImpl *)jarg1;
39619   arg2 = (Dali::KeyEvent *)jarg2;
39620   if (!arg2) {
39621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39622     return 0;
39623   }
39624   {
39625     try {
39626       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39627     } catch (std::out_of_range& e) {
39628       {
39629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39630       };
39631     } catch (std::exception& e) {
39632       {
39633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39634       };
39635     } catch (Dali::DaliException e) {
39636       {
39637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39638       };
39639     } catch (...) {
39640       {
39641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39642       };
39643     }
39644   }
39645
39646   jresult = result;
39647   return jresult;
39648 }
39649
39650
39651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39652   unsigned int jresult ;
39653   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39654   Dali::WheelEvent *arg2 = 0 ;
39655   bool result;
39656
39657   arg1 = (Dali::CustomActorImpl *)jarg1;
39658   arg2 = (Dali::WheelEvent *)jarg2;
39659   if (!arg2) {
39660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39661     return 0;
39662   }
39663   {
39664     try {
39665       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39666     } catch (std::out_of_range& e) {
39667       {
39668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39669       };
39670     } catch (std::exception& e) {
39671       {
39672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39673       };
39674     } catch (Dali::DaliException e) {
39675       {
39676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39677       };
39678     } catch (...) {
39679       {
39680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39681       };
39682     }
39683   }
39684
39685   jresult = result;
39686   return jresult;
39687 }
39688
39689
39690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39691   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39692   Dali::Vector2 *arg2 = 0 ;
39693   Dali::RelayoutContainer *arg3 = 0 ;
39694
39695   arg1 = (Dali::CustomActorImpl *)jarg1;
39696   arg2 = (Dali::Vector2 *)jarg2;
39697   if (!arg2) {
39698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39699     return ;
39700   }
39701   arg3 = (Dali::RelayoutContainer *)jarg3;
39702   if (!arg3) {
39703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39704     return ;
39705   }
39706   {
39707     try {
39708       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39709     } catch (std::out_of_range& e) {
39710       {
39711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39712       };
39713     } catch (std::exception& e) {
39714       {
39715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39716       };
39717     } catch (Dali::DaliException e) {
39718       {
39719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39720       };
39721     } catch (...) {
39722       {
39723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39724       };
39725     }
39726   }
39727
39728 }
39729
39730
39731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39732   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39733   Dali::ResizePolicy::Type arg2 ;
39734   Dali::Dimension::Type arg3 ;
39735
39736   arg1 = (Dali::CustomActorImpl *)jarg1;
39737   arg2 = (Dali::ResizePolicy::Type)jarg2;
39738   arg3 = (Dali::Dimension::Type)jarg3;
39739   {
39740     try {
39741       (arg1)->OnSetResizePolicy(arg2,arg3);
39742     } catch (std::out_of_range& e) {
39743       {
39744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39745       };
39746     } catch (std::exception& e) {
39747       {
39748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39749       };
39750     } catch (Dali::DaliException e) {
39751       {
39752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39753       };
39754     } catch (...) {
39755       {
39756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39757       };
39758     }
39759   }
39760
39761 }
39762
39763
39764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39765   void * jresult ;
39766   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39767   Dali::Vector3 result;
39768
39769   arg1 = (Dali::CustomActorImpl *)jarg1;
39770   {
39771     try {
39772       result = (arg1)->GetNaturalSize();
39773     } catch (std::out_of_range& e) {
39774       {
39775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39776       };
39777     } catch (std::exception& e) {
39778       {
39779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39780       };
39781     } catch (Dali::DaliException e) {
39782       {
39783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39784       };
39785     } catch (...) {
39786       {
39787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39788       };
39789     }
39790   }
39791
39792   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39793   return jresult;
39794 }
39795
39796
39797 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39798   float jresult ;
39799   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39800   Dali::Actor *arg2 = 0 ;
39801   Dali::Dimension::Type arg3 ;
39802   float result;
39803
39804   arg1 = (Dali::CustomActorImpl *)jarg1;
39805   arg2 = (Dali::Actor *)jarg2;
39806   if (!arg2) {
39807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39808     return 0;
39809   }
39810   arg3 = (Dali::Dimension::Type)jarg3;
39811   {
39812     try {
39813       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39814     } catch (std::out_of_range& e) {
39815       {
39816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39817       };
39818     } catch (std::exception& e) {
39819       {
39820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39821       };
39822     } catch (Dali::DaliException e) {
39823       {
39824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39825       };
39826     } catch (...) {
39827       {
39828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39829       };
39830     }
39831   }
39832
39833   jresult = result;
39834   return jresult;
39835 }
39836
39837
39838 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39839   float jresult ;
39840   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39841   float arg2 ;
39842   float result;
39843
39844   arg1 = (Dali::CustomActorImpl *)jarg1;
39845   arg2 = (float)jarg2;
39846   {
39847     try {
39848       result = (float)(arg1)->GetHeightForWidth(arg2);
39849     } catch (std::out_of_range& e) {
39850       {
39851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39852       };
39853     } catch (std::exception& e) {
39854       {
39855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39856       };
39857     } catch (Dali::DaliException e) {
39858       {
39859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39860       };
39861     } catch (...) {
39862       {
39863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39864       };
39865     }
39866   }
39867
39868   jresult = result;
39869   return jresult;
39870 }
39871
39872
39873 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39874   float jresult ;
39875   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39876   float arg2 ;
39877   float result;
39878
39879   arg1 = (Dali::CustomActorImpl *)jarg1;
39880   arg2 = (float)jarg2;
39881   {
39882     try {
39883       result = (float)(arg1)->GetWidthForHeight(arg2);
39884     } catch (std::out_of_range& e) {
39885       {
39886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39887       };
39888     } catch (std::exception& e) {
39889       {
39890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39891       };
39892     } catch (Dali::DaliException e) {
39893       {
39894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39895       };
39896     } catch (...) {
39897       {
39898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39899       };
39900     }
39901   }
39902
39903   jresult = result;
39904   return jresult;
39905 }
39906
39907
39908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39909   unsigned int jresult ;
39910   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39911   Dali::Dimension::Type arg2 ;
39912   bool result;
39913
39914   arg1 = (Dali::CustomActorImpl *)jarg1;
39915   arg2 = (Dali::Dimension::Type)jarg2;
39916   {
39917     try {
39918       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39919     } catch (std::out_of_range& e) {
39920       {
39921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39922       };
39923     } catch (std::exception& e) {
39924       {
39925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39926       };
39927     } catch (Dali::DaliException e) {
39928       {
39929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39930       };
39931     } catch (...) {
39932       {
39933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39934       };
39935     }
39936   }
39937
39938   jresult = result;
39939   return jresult;
39940 }
39941
39942
39943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39944   unsigned int jresult ;
39945   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39946   bool result;
39947
39948   arg1 = (Dali::CustomActorImpl *)jarg1;
39949   {
39950     try {
39951       result = (bool)(arg1)->RelayoutDependentOnChildren();
39952     } catch (std::out_of_range& e) {
39953       {
39954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39955       };
39956     } catch (std::exception& e) {
39957       {
39958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39959       };
39960     } catch (Dali::DaliException e) {
39961       {
39962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39963       };
39964     } catch (...) {
39965       {
39966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39967       };
39968     }
39969   }
39970
39971   jresult = result;
39972   return jresult;
39973 }
39974
39975
39976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39977   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39978   Dali::Dimension::Type arg2 ;
39979
39980   arg1 = (Dali::CustomActorImpl *)jarg1;
39981   arg2 = (Dali::Dimension::Type)jarg2;
39982   {
39983     try {
39984       (arg1)->OnCalculateRelayoutSize(arg2);
39985     } catch (std::out_of_range& e) {
39986       {
39987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39988       };
39989     } catch (std::exception& e) {
39990       {
39991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39992       };
39993     } catch (Dali::DaliException e) {
39994       {
39995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39996       };
39997     } catch (...) {
39998       {
39999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40000       };
40001     }
40002   }
40003
40004 }
40005
40006
40007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
40008   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40009   float arg2 ;
40010   Dali::Dimension::Type arg3 ;
40011
40012   arg1 = (Dali::CustomActorImpl *)jarg1;
40013   arg2 = (float)jarg2;
40014   arg3 = (Dali::Dimension::Type)jarg3;
40015   {
40016     try {
40017       (arg1)->OnLayoutNegotiated(arg2,arg3);
40018     } catch (std::out_of_range& e) {
40019       {
40020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40021       };
40022     } catch (std::exception& e) {
40023       {
40024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40025       };
40026     } catch (Dali::DaliException e) {
40027       {
40028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40029       };
40030     } catch (...) {
40031       {
40032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40033       };
40034     }
40035   }
40036
40037 }
40038
40039
40040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
40041   unsigned int jresult ;
40042   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40043   bool result;
40044
40045   arg1 = (Dali::CustomActorImpl *)jarg1;
40046   {
40047     try {
40048       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
40049     } catch (std::out_of_range& e) {
40050       {
40051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40052       };
40053     } catch (std::exception& e) {
40054       {
40055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40056       };
40057     } catch (Dali::DaliException e) {
40058       {
40059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40060       };
40061     } catch (...) {
40062       {
40063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40064       };
40065     }
40066   }
40067
40068   jresult = result;
40069   return jresult;
40070 }
40071
40072
40073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40074   unsigned int jresult ;
40075   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40076   bool result;
40077
40078   arg1 = (Dali::CustomActorImpl *)jarg1;
40079   {
40080     try {
40081       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40082     } catch (std::out_of_range& e) {
40083       {
40084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40085       };
40086     } catch (std::exception& e) {
40087       {
40088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40089       };
40090     } catch (Dali::DaliException e) {
40091       {
40092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40093       };
40094     } catch (...) {
40095       {
40096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40097       };
40098     }
40099   }
40100
40101   jresult = result;
40102   return jresult;
40103 }
40104
40105
40106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40107   unsigned int jresult ;
40108   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40109   bool result;
40110
40111   arg1 = (Dali::CustomActorImpl *)jarg1;
40112   {
40113     try {
40114       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40115     } catch (std::out_of_range& e) {
40116       {
40117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40118       };
40119     } catch (std::exception& e) {
40120       {
40121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40122       };
40123     } catch (Dali::DaliException e) {
40124       {
40125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40126       };
40127     } catch (...) {
40128       {
40129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40130       };
40131     }
40132   }
40133
40134   jresult = result;
40135   return jresult;
40136 }
40137
40138
40139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40140   unsigned int jresult ;
40141   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40142   bool result;
40143
40144   arg1 = (Dali::CustomActorImpl *)jarg1;
40145   {
40146     try {
40147       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40148     } catch (std::out_of_range& e) {
40149       {
40150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40151       };
40152     } catch (std::exception& e) {
40153       {
40154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40155       };
40156     } catch (Dali::DaliException e) {
40157       {
40158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40159       };
40160     } catch (...) {
40161       {
40162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40163       };
40164     }
40165   }
40166
40167   jresult = result;
40168   return jresult;
40169 }
40170
40171
40172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40173   void * jresult ;
40174   Dali::CustomActor *result = 0 ;
40175
40176   {
40177     try {
40178       result = (Dali::CustomActor *)new Dali::CustomActor();
40179     } catch (std::out_of_range& e) {
40180       {
40181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40182       };
40183     } catch (std::exception& e) {
40184       {
40185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40186       };
40187     } catch (Dali::DaliException e) {
40188       {
40189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40190       };
40191     } catch (...) {
40192       {
40193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40194       };
40195     }
40196   }
40197
40198   jresult = (void *)result;
40199   return jresult;
40200 }
40201
40202
40203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40204   void * jresult ;
40205   Dali::BaseHandle arg1 ;
40206   Dali::BaseHandle *argp1 ;
40207   Dali::CustomActor result;
40208
40209   argp1 = (Dali::BaseHandle *)jarg1;
40210   if (!argp1) {
40211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40212     return 0;
40213   }
40214   arg1 = *argp1;
40215   {
40216     try {
40217       result = Dali::CustomActor::DownCast(arg1);
40218     } catch (std::out_of_range& e) {
40219       {
40220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40221       };
40222     } catch (std::exception& e) {
40223       {
40224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40225       };
40226     } catch (Dali::DaliException e) {
40227       {
40228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40229       };
40230     } catch (...) {
40231       {
40232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40233       };
40234     }
40235   }
40236
40237   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40238   return jresult;
40239 }
40240
40241
40242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40243   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40244
40245   arg1 = (Dali::CustomActor *)jarg1;
40246   {
40247     try {
40248       delete arg1;
40249     } catch (std::out_of_range& e) {
40250       {
40251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40252       };
40253     } catch (std::exception& e) {
40254       {
40255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40256       };
40257     } catch (Dali::DaliException e) {
40258       {
40259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40260       };
40261     } catch (...) {
40262       {
40263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40264       };
40265     }
40266   }
40267
40268 }
40269
40270
40271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40272   void * jresult ;
40273   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40274   Dali::CustomActorImpl *result = 0 ;
40275
40276   arg1 = (Dali::CustomActor *)jarg1;
40277   {
40278     try {
40279       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40280     } catch (std::out_of_range& e) {
40281       {
40282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40283       };
40284     } catch (std::exception& e) {
40285       {
40286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40287       };
40288     } catch (Dali::DaliException e) {
40289       {
40290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40291       };
40292     } catch (...) {
40293       {
40294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40295       };
40296     }
40297   }
40298
40299   jresult = (void *)result;
40300   return jresult;
40301 }
40302
40303
40304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40305   void * jresult ;
40306   Dali::CustomActorImpl *arg1 = 0 ;
40307   Dali::CustomActor *result = 0 ;
40308
40309   arg1 = (Dali::CustomActorImpl *)jarg1;
40310   if (!arg1) {
40311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40312     return 0;
40313   }
40314   {
40315     try {
40316       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40317     } catch (std::out_of_range& e) {
40318       {
40319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40320       };
40321     } catch (std::exception& e) {
40322       {
40323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40324       };
40325     } catch (Dali::DaliException e) {
40326       {
40327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40328       };
40329     } catch (...) {
40330       {
40331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40332       };
40333     }
40334   }
40335
40336   jresult = (void *)result;
40337   return jresult;
40338 }
40339
40340
40341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40342   void * jresult ;
40343   Dali::CustomActor *arg1 = 0 ;
40344   Dali::CustomActor *result = 0 ;
40345
40346   arg1 = (Dali::CustomActor *)jarg1;
40347   if (!arg1) {
40348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40349     return 0;
40350   }
40351   {
40352     try {
40353       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40354     } catch (std::out_of_range& e) {
40355       {
40356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40357       };
40358     } catch (std::exception& e) {
40359       {
40360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40361       };
40362     } catch (Dali::DaliException e) {
40363       {
40364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40365       };
40366     } catch (...) {
40367       {
40368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40369       };
40370     }
40371   }
40372
40373   jresult = (void *)result;
40374   return jresult;
40375 }
40376
40377
40378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40379   void * jresult ;
40380   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40381   Dali::CustomActor *arg2 = 0 ;
40382   Dali::CustomActor *result = 0 ;
40383
40384   arg1 = (Dali::CustomActor *)jarg1;
40385   arg2 = (Dali::CustomActor *)jarg2;
40386   if (!arg2) {
40387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40388     return 0;
40389   }
40390   {
40391     try {
40392       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40393     } catch (std::out_of_range& e) {
40394       {
40395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40396       };
40397     } catch (std::exception& e) {
40398       {
40399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40400       };
40401     } catch (Dali::DaliException e) {
40402       {
40403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40404       };
40405     } catch (...) {
40406       {
40407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40408       };
40409     }
40410   }
40411
40412   jresult = (void *)result;
40413   return jresult;
40414 }
40415
40416
40417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40418   int jresult ;
40419   int result;
40420
40421   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40422   jresult = (int)result;
40423   return jresult;
40424 }
40425
40426
40427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40428   int jresult ;
40429   int result;
40430
40431   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40432   jresult = (int)result;
40433   return jresult;
40434 }
40435
40436
40437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40438   int jresult ;
40439   int result;
40440
40441   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40442   jresult = (int)result;
40443   return jresult;
40444 }
40445
40446
40447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40448   int jresult ;
40449   int result;
40450
40451   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40452   jresult = (int)result;
40453   return jresult;
40454 }
40455
40456
40457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40458   int jresult ;
40459   int result;
40460
40461   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40462   jresult = (int)result;
40463   return jresult;
40464 }
40465
40466
40467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40468   int jresult ;
40469   int result;
40470
40471   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40472   jresult = (int)result;
40473   return jresult;
40474 }
40475
40476
40477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40478   int jresult ;
40479   int result;
40480
40481   result = (int)Dali::PanGestureDetector::Property::PANNING;
40482   jresult = (int)result;
40483   return jresult;
40484 }
40485
40486
40487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40488   void * jresult ;
40489   Dali::PanGestureDetector::Property *result = 0 ;
40490
40491   {
40492     try {
40493       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40494     } catch (std::out_of_range& e) {
40495       {
40496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40497       };
40498     } catch (std::exception& e) {
40499       {
40500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40501       };
40502     } catch (Dali::DaliException e) {
40503       {
40504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40505       };
40506     } catch (...) {
40507       {
40508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40509       };
40510     }
40511   }
40512
40513   jresult = (void *)result;
40514   return jresult;
40515 }
40516
40517
40518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40519   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40520
40521   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40522   {
40523     try {
40524       delete arg1;
40525     } catch (std::out_of_range& e) {
40526       {
40527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40528       };
40529     } catch (std::exception& e) {
40530       {
40531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40532       };
40533     } catch (Dali::DaliException e) {
40534       {
40535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40536       };
40537     } catch (...) {
40538       {
40539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40540       };
40541     }
40542   }
40543
40544 }
40545
40546
40547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40548   void * jresult ;
40549   Dali::Radian *result = 0 ;
40550
40551   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40552   jresult = (void *)result;
40553   return jresult;
40554 }
40555
40556
40557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40558   void * jresult ;
40559   Dali::Radian *result = 0 ;
40560
40561   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40562   jresult = (void *)result;
40563   return jresult;
40564 }
40565
40566
40567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40568   void * jresult ;
40569   Dali::Radian *result = 0 ;
40570
40571   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40572   jresult = (void *)result;
40573   return jresult;
40574 }
40575
40576
40577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40578   void * jresult ;
40579   Dali::Radian *result = 0 ;
40580
40581   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40582   jresult = (void *)result;
40583   return jresult;
40584 }
40585
40586
40587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40588   void * jresult ;
40589   Dali::Radian *result = 0 ;
40590
40591   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40592   jresult = (void *)result;
40593   return jresult;
40594 }
40595
40596
40597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40598   void * jresult ;
40599   Dali::Radian *result = 0 ;
40600
40601   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40602   jresult = (void *)result;
40603   return jresult;
40604 }
40605
40606
40607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40608   void * jresult ;
40609   Dali::Radian *result = 0 ;
40610
40611   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40612   jresult = (void *)result;
40613   return jresult;
40614 }
40615
40616
40617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40618   void * jresult ;
40619   Dali::PanGestureDetector *result = 0 ;
40620
40621   {
40622     try {
40623       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40624     } catch (std::out_of_range& e) {
40625       {
40626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40627       };
40628     } catch (std::exception& e) {
40629       {
40630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40631       };
40632     } catch (Dali::DaliException e) {
40633       {
40634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40635       };
40636     } catch (...) {
40637       {
40638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40639       };
40640     }
40641   }
40642
40643   jresult = (void *)result;
40644   return jresult;
40645 }
40646
40647
40648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40649   void * jresult ;
40650   Dali::PanGestureDetector result;
40651
40652   {
40653     try {
40654       result = Dali::PanGestureDetector::New();
40655     } catch (std::out_of_range& e) {
40656       {
40657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40658       };
40659     } catch (std::exception& e) {
40660       {
40661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40662       };
40663     } catch (Dali::DaliException e) {
40664       {
40665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40666       };
40667     } catch (...) {
40668       {
40669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40670       };
40671     }
40672   }
40673
40674   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40675   return jresult;
40676 }
40677
40678
40679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40680   void * jresult ;
40681   Dali::BaseHandle arg1 ;
40682   Dali::BaseHandle *argp1 ;
40683   Dali::PanGestureDetector result;
40684
40685   argp1 = (Dali::BaseHandle *)jarg1;
40686   if (!argp1) {
40687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40688     return 0;
40689   }
40690   arg1 = *argp1;
40691   {
40692     try {
40693       result = Dali::PanGestureDetector::DownCast(arg1);
40694     } catch (std::out_of_range& e) {
40695       {
40696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40697       };
40698     } catch (std::exception& e) {
40699       {
40700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40701       };
40702     } catch (Dali::DaliException e) {
40703       {
40704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40705       };
40706     } catch (...) {
40707       {
40708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40709       };
40710     }
40711   }
40712
40713   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40714   return jresult;
40715 }
40716
40717
40718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40719   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40720
40721   arg1 = (Dali::PanGestureDetector *)jarg1;
40722   {
40723     try {
40724       delete arg1;
40725     } catch (std::out_of_range& e) {
40726       {
40727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40728       };
40729     } catch (std::exception& e) {
40730       {
40731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40732       };
40733     } catch (Dali::DaliException e) {
40734       {
40735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40736       };
40737     } catch (...) {
40738       {
40739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40740       };
40741     }
40742   }
40743
40744 }
40745
40746
40747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40748   void * jresult ;
40749   Dali::PanGestureDetector *arg1 = 0 ;
40750   Dali::PanGestureDetector *result = 0 ;
40751
40752   arg1 = (Dali::PanGestureDetector *)jarg1;
40753   if (!arg1) {
40754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40755     return 0;
40756   }
40757   {
40758     try {
40759       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40760     } catch (std::out_of_range& e) {
40761       {
40762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40763       };
40764     } catch (std::exception& e) {
40765       {
40766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40767       };
40768     } catch (Dali::DaliException e) {
40769       {
40770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40771       };
40772     } catch (...) {
40773       {
40774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40775       };
40776     }
40777   }
40778
40779   jresult = (void *)result;
40780   return jresult;
40781 }
40782
40783
40784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40785   void * jresult ;
40786   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40787   Dali::PanGestureDetector *arg2 = 0 ;
40788   Dali::PanGestureDetector *result = 0 ;
40789
40790   arg1 = (Dali::PanGestureDetector *)jarg1;
40791   arg2 = (Dali::PanGestureDetector *)jarg2;
40792   if (!arg2) {
40793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40794     return 0;
40795   }
40796   {
40797     try {
40798       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40799     } catch (std::out_of_range& e) {
40800       {
40801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40802       };
40803     } catch (std::exception& e) {
40804       {
40805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40806       };
40807     } catch (Dali::DaliException e) {
40808       {
40809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40810       };
40811     } catch (...) {
40812       {
40813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40814       };
40815     }
40816   }
40817
40818   jresult = (void *)result;
40819   return jresult;
40820 }
40821
40822
40823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40824   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40825   unsigned int arg2 ;
40826
40827   arg1 = (Dali::PanGestureDetector *)jarg1;
40828   arg2 = (unsigned int)jarg2;
40829   {
40830     try {
40831       (arg1)->SetMinimumTouchesRequired(arg2);
40832     } catch (std::out_of_range& e) {
40833       {
40834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40835       };
40836     } catch (std::exception& e) {
40837       {
40838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40839       };
40840     } catch (Dali::DaliException e) {
40841       {
40842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40843       };
40844     } catch (...) {
40845       {
40846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40847       };
40848     }
40849   }
40850
40851 }
40852
40853
40854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40855   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40856   unsigned int arg2 ;
40857
40858   arg1 = (Dali::PanGestureDetector *)jarg1;
40859   arg2 = (unsigned int)jarg2;
40860   {
40861     try {
40862       (arg1)->SetMaximumTouchesRequired(arg2);
40863     } catch (std::out_of_range& e) {
40864       {
40865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40866       };
40867     } catch (std::exception& e) {
40868       {
40869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40870       };
40871     } catch (Dali::DaliException e) {
40872       {
40873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40874       };
40875     } catch (...) {
40876       {
40877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40878       };
40879     }
40880   }
40881
40882 }
40883
40884
40885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40886   unsigned int jresult ;
40887   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40888   unsigned int result;
40889
40890   arg1 = (Dali::PanGestureDetector *)jarg1;
40891   {
40892     try {
40893       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40894     } catch (std::out_of_range& e) {
40895       {
40896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40897       };
40898     } catch (std::exception& e) {
40899       {
40900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40901       };
40902     } catch (Dali::DaliException e) {
40903       {
40904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40905       };
40906     } catch (...) {
40907       {
40908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40909       };
40910     }
40911   }
40912
40913   jresult = result;
40914   return jresult;
40915 }
40916
40917
40918 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40919   unsigned int jresult ;
40920   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40921   unsigned int result;
40922
40923   arg1 = (Dali::PanGestureDetector *)jarg1;
40924   {
40925     try {
40926       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40927     } catch (std::out_of_range& e) {
40928       {
40929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40930       };
40931     } catch (std::exception& e) {
40932       {
40933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40934       };
40935     } catch (Dali::DaliException e) {
40936       {
40937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40938       };
40939     } catch (...) {
40940       {
40941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40942       };
40943     }
40944   }
40945
40946   jresult = result;
40947   return jresult;
40948 }
40949
40950
40951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40952   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40953   Dali::Radian arg2 ;
40954   Dali::Radian arg3 ;
40955   Dali::Radian *argp2 ;
40956   Dali::Radian *argp3 ;
40957
40958   arg1 = (Dali::PanGestureDetector *)jarg1;
40959   argp2 = (Dali::Radian *)jarg2;
40960   if (!argp2) {
40961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40962     return ;
40963   }
40964   arg2 = *argp2;
40965   argp3 = (Dali::Radian *)jarg3;
40966   if (!argp3) {
40967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40968     return ;
40969   }
40970   arg3 = *argp3;
40971   {
40972     try {
40973       (arg1)->AddAngle(arg2,arg3);
40974     } catch (std::out_of_range& e) {
40975       {
40976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40977       };
40978     } catch (std::exception& e) {
40979       {
40980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40981       };
40982     } catch (Dali::DaliException e) {
40983       {
40984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40985       };
40986     } catch (...) {
40987       {
40988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40989       };
40990     }
40991   }
40992
40993 }
40994
40995
40996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40997   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40998   Dali::Radian arg2 ;
40999   Dali::Radian *argp2 ;
41000
41001   arg1 = (Dali::PanGestureDetector *)jarg1;
41002   argp2 = (Dali::Radian *)jarg2;
41003   if (!argp2) {
41004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41005     return ;
41006   }
41007   arg2 = *argp2;
41008   {
41009     try {
41010       (arg1)->AddAngle(arg2);
41011     } catch (std::out_of_range& e) {
41012       {
41013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41014       };
41015     } catch (std::exception& e) {
41016       {
41017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41018       };
41019     } catch (Dali::DaliException e) {
41020       {
41021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41022       };
41023     } catch (...) {
41024       {
41025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41026       };
41027     }
41028   }
41029
41030 }
41031
41032
41033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41034   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41035   Dali::Radian arg2 ;
41036   Dali::Radian arg3 ;
41037   Dali::Radian *argp2 ;
41038   Dali::Radian *argp3 ;
41039
41040   arg1 = (Dali::PanGestureDetector *)jarg1;
41041   argp2 = (Dali::Radian *)jarg2;
41042   if (!argp2) {
41043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41044     return ;
41045   }
41046   arg2 = *argp2;
41047   argp3 = (Dali::Radian *)jarg3;
41048   if (!argp3) {
41049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41050     return ;
41051   }
41052   arg3 = *argp3;
41053   {
41054     try {
41055       (arg1)->AddDirection(arg2,arg3);
41056     } catch (std::out_of_range& e) {
41057       {
41058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41059       };
41060     } catch (std::exception& e) {
41061       {
41062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41063       };
41064     } catch (Dali::DaliException e) {
41065       {
41066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41067       };
41068     } catch (...) {
41069       {
41070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41071       };
41072     }
41073   }
41074
41075 }
41076
41077
41078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41079   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41080   Dali::Radian arg2 ;
41081   Dali::Radian *argp2 ;
41082
41083   arg1 = (Dali::PanGestureDetector *)jarg1;
41084   argp2 = (Dali::Radian *)jarg2;
41085   if (!argp2) {
41086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41087     return ;
41088   }
41089   arg2 = *argp2;
41090   {
41091     try {
41092       (arg1)->AddDirection(arg2);
41093     } catch (std::out_of_range& e) {
41094       {
41095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41096       };
41097     } catch (std::exception& e) {
41098       {
41099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41100       };
41101     } catch (Dali::DaliException e) {
41102       {
41103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41104       };
41105     } catch (...) {
41106       {
41107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41108       };
41109     }
41110   }
41111
41112 }
41113
41114
41115 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41116   unsigned long jresult ;
41117   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41118   size_t result;
41119
41120   arg1 = (Dali::PanGestureDetector *)jarg1;
41121   {
41122     try {
41123       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41124     } catch (std::out_of_range& e) {
41125       {
41126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41127       };
41128     } catch (std::exception& e) {
41129       {
41130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41131       };
41132     } catch (Dali::DaliException e) {
41133       {
41134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41135       };
41136     } catch (...) {
41137       {
41138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41139       };
41140     }
41141   }
41142
41143   jresult = (unsigned long)result;
41144   return jresult;
41145 }
41146
41147
41148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41149   void * jresult ;
41150   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41151   size_t arg2 ;
41152   Dali::PanGestureDetector::AngleThresholdPair result;
41153
41154   arg1 = (Dali::PanGestureDetector *)jarg1;
41155   arg2 = (size_t)jarg2;
41156   {
41157     try {
41158       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41159     } catch (std::out_of_range& e) {
41160       {
41161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41162       };
41163     } catch (std::exception& e) {
41164       {
41165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41166       };
41167     } catch (Dali::DaliException e) {
41168       {
41169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41170       };
41171     } catch (...) {
41172       {
41173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41174       };
41175     }
41176   }
41177
41178   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41179   return jresult;
41180 }
41181
41182
41183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41184   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41185
41186   arg1 = (Dali::PanGestureDetector *)jarg1;
41187   {
41188     try {
41189       (arg1)->ClearAngles();
41190     } catch (std::out_of_range& e) {
41191       {
41192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41193       };
41194     } catch (std::exception& e) {
41195       {
41196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41197       };
41198     } catch (Dali::DaliException e) {
41199       {
41200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41201       };
41202     } catch (...) {
41203       {
41204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41205       };
41206     }
41207   }
41208
41209 }
41210
41211
41212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41213   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41214   Dali::Radian arg2 ;
41215   Dali::Radian *argp2 ;
41216
41217   arg1 = (Dali::PanGestureDetector *)jarg1;
41218   argp2 = (Dali::Radian *)jarg2;
41219   if (!argp2) {
41220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41221     return ;
41222   }
41223   arg2 = *argp2;
41224   {
41225     try {
41226       (arg1)->RemoveAngle(arg2);
41227     } catch (std::out_of_range& e) {
41228       {
41229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41230       };
41231     } catch (std::exception& e) {
41232       {
41233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41234       };
41235     } catch (Dali::DaliException e) {
41236       {
41237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41238       };
41239     } catch (...) {
41240       {
41241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41242       };
41243     }
41244   }
41245
41246 }
41247
41248
41249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41250   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41251   Dali::Radian arg2 ;
41252   Dali::Radian *argp2 ;
41253
41254   arg1 = (Dali::PanGestureDetector *)jarg1;
41255   argp2 = (Dali::Radian *)jarg2;
41256   if (!argp2) {
41257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41258     return ;
41259   }
41260   arg2 = *argp2;
41261   {
41262     try {
41263       (arg1)->RemoveDirection(arg2);
41264     } catch (std::out_of_range& e) {
41265       {
41266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41267       };
41268     } catch (std::exception& e) {
41269       {
41270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41271       };
41272     } catch (Dali::DaliException e) {
41273       {
41274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41275       };
41276     } catch (...) {
41277       {
41278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41279       };
41280     }
41281   }
41282
41283 }
41284
41285
41286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41287   void * jresult ;
41288   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41289   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41290
41291   arg1 = (Dali::PanGestureDetector *)jarg1;
41292   {
41293     try {
41294       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41295     } catch (std::out_of_range& e) {
41296       {
41297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41298       };
41299     } catch (std::exception& e) {
41300       {
41301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41302       };
41303     } catch (Dali::DaliException e) {
41304       {
41305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41306       };
41307     } catch (...) {
41308       {
41309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41310       };
41311     }
41312   }
41313
41314   jresult = (void *)result;
41315   return jresult;
41316 }
41317
41318
41319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41320   Dali::PanGesture *arg1 = 0 ;
41321
41322   arg1 = (Dali::PanGesture *)jarg1;
41323   if (!arg1) {
41324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41325     return ;
41326   }
41327   {
41328     try {
41329       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41330     } catch (std::out_of_range& e) {
41331       {
41332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41333       };
41334     } catch (std::exception& e) {
41335       {
41336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41337       };
41338     } catch (Dali::DaliException e) {
41339       {
41340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41341       };
41342     } catch (...) {
41343       {
41344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41345       };
41346     }
41347   }
41348
41349 }
41350
41351
41352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41353   void * jresult ;
41354   Dali::PanGesture *result = 0 ;
41355
41356   {
41357     try {
41358       result = (Dali::PanGesture *)new Dali::PanGesture();
41359     } catch (std::out_of_range& e) {
41360       {
41361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41362       };
41363     } catch (std::exception& e) {
41364       {
41365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41366       };
41367     } catch (Dali::DaliException e) {
41368       {
41369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41370       };
41371     } catch (...) {
41372       {
41373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41374       };
41375     }
41376   }
41377
41378   jresult = (void *)result;
41379   return jresult;
41380 }
41381
41382
41383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41384   void * jresult ;
41385   Dali::Gesture::State arg1 ;
41386   Dali::PanGesture *result = 0 ;
41387
41388   arg1 = (Dali::Gesture::State)jarg1;
41389   {
41390     try {
41391       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41392     } catch (std::out_of_range& e) {
41393       {
41394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41395       };
41396     } catch (std::exception& e) {
41397       {
41398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41399       };
41400     } catch (Dali::DaliException e) {
41401       {
41402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41403       };
41404     } catch (...) {
41405       {
41406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41407       };
41408     }
41409   }
41410
41411   jresult = (void *)result;
41412   return jresult;
41413 }
41414
41415
41416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41417   void * jresult ;
41418   Dali::PanGesture *arg1 = 0 ;
41419   Dali::PanGesture *result = 0 ;
41420
41421   arg1 = (Dali::PanGesture *)jarg1;
41422   if (!arg1) {
41423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41424     return 0;
41425   }
41426   {
41427     try {
41428       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41429     } catch (std::out_of_range& e) {
41430       {
41431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41432       };
41433     } catch (std::exception& e) {
41434       {
41435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41436       };
41437     } catch (Dali::DaliException e) {
41438       {
41439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41440       };
41441     } catch (...) {
41442       {
41443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41444       };
41445     }
41446   }
41447
41448   jresult = (void *)result;
41449   return jresult;
41450 }
41451
41452
41453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41454   void * jresult ;
41455   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41456   Dali::PanGesture *arg2 = 0 ;
41457   Dali::PanGesture *result = 0 ;
41458
41459   arg1 = (Dali::PanGesture *)jarg1;
41460   arg2 = (Dali::PanGesture *)jarg2;
41461   if (!arg2) {
41462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41463     return 0;
41464   }
41465   {
41466     try {
41467       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41468     } catch (std::out_of_range& e) {
41469       {
41470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41471       };
41472     } catch (std::exception& e) {
41473       {
41474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41475       };
41476     } catch (Dali::DaliException e) {
41477       {
41478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41479       };
41480     } catch (...) {
41481       {
41482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41483       };
41484     }
41485   }
41486
41487   jresult = (void *)result;
41488   return jresult;
41489 }
41490
41491
41492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41493   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41494
41495   arg1 = (Dali::PanGesture *)jarg1;
41496   {
41497     try {
41498       delete arg1;
41499     } catch (std::out_of_range& e) {
41500       {
41501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41502       };
41503     } catch (std::exception& e) {
41504       {
41505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41506       };
41507     } catch (Dali::DaliException e) {
41508       {
41509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41510       };
41511     } catch (...) {
41512       {
41513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41514       };
41515     }
41516   }
41517
41518 }
41519
41520
41521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41522   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41523   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41524
41525   arg1 = (Dali::PanGesture *)jarg1;
41526   arg2 = (Dali::Vector2 *)jarg2;
41527   if (arg1) (arg1)->velocity = *arg2;
41528 }
41529
41530
41531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41532   void * jresult ;
41533   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41534   Dali::Vector2 *result = 0 ;
41535
41536   arg1 = (Dali::PanGesture *)jarg1;
41537   result = (Dali::Vector2 *)& ((arg1)->velocity);
41538   jresult = (void *)result;
41539   return jresult;
41540 }
41541
41542
41543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41544   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41545   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41546
41547   arg1 = (Dali::PanGesture *)jarg1;
41548   arg2 = (Dali::Vector2 *)jarg2;
41549   if (arg1) (arg1)->displacement = *arg2;
41550 }
41551
41552
41553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41554   void * jresult ;
41555   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41556   Dali::Vector2 *result = 0 ;
41557
41558   arg1 = (Dali::PanGesture *)jarg1;
41559   result = (Dali::Vector2 *)& ((arg1)->displacement);
41560   jresult = (void *)result;
41561   return jresult;
41562 }
41563
41564
41565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41566   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41567   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41568
41569   arg1 = (Dali::PanGesture *)jarg1;
41570   arg2 = (Dali::Vector2 *)jarg2;
41571   if (arg1) (arg1)->position = *arg2;
41572 }
41573
41574
41575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41576   void * jresult ;
41577   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41578   Dali::Vector2 *result = 0 ;
41579
41580   arg1 = (Dali::PanGesture *)jarg1;
41581   result = (Dali::Vector2 *)& ((arg1)->position);
41582   jresult = (void *)result;
41583   return jresult;
41584 }
41585
41586
41587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41588   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41589   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41590
41591   arg1 = (Dali::PanGesture *)jarg1;
41592   arg2 = (Dali::Vector2 *)jarg2;
41593   if (arg1) (arg1)->screenVelocity = *arg2;
41594 }
41595
41596
41597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41598   void * jresult ;
41599   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41600   Dali::Vector2 *result = 0 ;
41601
41602   arg1 = (Dali::PanGesture *)jarg1;
41603   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41604   jresult = (void *)result;
41605   return jresult;
41606 }
41607
41608
41609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41610   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41611   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41612
41613   arg1 = (Dali::PanGesture *)jarg1;
41614   arg2 = (Dali::Vector2 *)jarg2;
41615   if (arg1) (arg1)->screenDisplacement = *arg2;
41616 }
41617
41618
41619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41620   void * jresult ;
41621   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41622   Dali::Vector2 *result = 0 ;
41623
41624   arg1 = (Dali::PanGesture *)jarg1;
41625   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41626   jresult = (void *)result;
41627   return jresult;
41628 }
41629
41630
41631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41632   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41633   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41634
41635   arg1 = (Dali::PanGesture *)jarg1;
41636   arg2 = (Dali::Vector2 *)jarg2;
41637   if (arg1) (arg1)->screenPosition = *arg2;
41638 }
41639
41640
41641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41642   void * jresult ;
41643   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41644   Dali::Vector2 *result = 0 ;
41645
41646   arg1 = (Dali::PanGesture *)jarg1;
41647   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41648   jresult = (void *)result;
41649   return jresult;
41650 }
41651
41652
41653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41654   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41655   unsigned int arg2 ;
41656
41657   arg1 = (Dali::PanGesture *)jarg1;
41658   arg2 = (unsigned int)jarg2;
41659   if (arg1) (arg1)->numberOfTouches = arg2;
41660 }
41661
41662
41663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41664   unsigned int jresult ;
41665   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41666   unsigned int result;
41667
41668   arg1 = (Dali::PanGesture *)jarg1;
41669   result = (unsigned int) ((arg1)->numberOfTouches);
41670   jresult = result;
41671   return jresult;
41672 }
41673
41674
41675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41676   float jresult ;
41677   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41678   float result;
41679
41680   arg1 = (Dali::PanGesture *)jarg1;
41681   {
41682     try {
41683       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41684     } catch (std::out_of_range& e) {
41685       {
41686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41687       };
41688     } catch (std::exception& e) {
41689       {
41690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41691       };
41692     } catch (Dali::DaliException e) {
41693       {
41694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41695       };
41696     } catch (...) {
41697       {
41698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41699       };
41700     }
41701   }
41702
41703   jresult = result;
41704   return jresult;
41705 }
41706
41707
41708 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41709   float jresult ;
41710   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41711   float result;
41712
41713   arg1 = (Dali::PanGesture *)jarg1;
41714   {
41715     try {
41716       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41717     } catch (std::out_of_range& e) {
41718       {
41719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41720       };
41721     } catch (std::exception& e) {
41722       {
41723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41724       };
41725     } catch (Dali::DaliException e) {
41726       {
41727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41728       };
41729     } catch (...) {
41730       {
41731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41732       };
41733     }
41734   }
41735
41736   jresult = result;
41737   return jresult;
41738 }
41739
41740
41741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41742   float jresult ;
41743   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41744   float result;
41745
41746   arg1 = (Dali::PanGesture *)jarg1;
41747   {
41748     try {
41749       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41750     } catch (std::out_of_range& e) {
41751       {
41752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41753       };
41754     } catch (std::exception& e) {
41755       {
41756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41757       };
41758     } catch (Dali::DaliException e) {
41759       {
41760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41761       };
41762     } catch (...) {
41763       {
41764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41765       };
41766     }
41767   }
41768
41769   jresult = result;
41770   return jresult;
41771 }
41772
41773
41774 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41775   float jresult ;
41776   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41777   float result;
41778
41779   arg1 = (Dali::PanGesture *)jarg1;
41780   {
41781     try {
41782       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41783     } catch (std::out_of_range& e) {
41784       {
41785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41786       };
41787     } catch (std::exception& e) {
41788       {
41789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41790       };
41791     } catch (Dali::DaliException e) {
41792       {
41793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41794       };
41795     } catch (...) {
41796       {
41797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41798       };
41799     }
41800   }
41801
41802   jresult = result;
41803   return jresult;
41804 }
41805
41806
41807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41808   void * jresult ;
41809   Dali::PinchGestureDetector *result = 0 ;
41810
41811   {
41812     try {
41813       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41814     } catch (std::out_of_range& e) {
41815       {
41816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41817       };
41818     } catch (std::exception& e) {
41819       {
41820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41821       };
41822     } catch (Dali::DaliException e) {
41823       {
41824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41825       };
41826     } catch (...) {
41827       {
41828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41829       };
41830     }
41831   }
41832
41833   jresult = (void *)result;
41834   return jresult;
41835 }
41836
41837
41838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41839   void * jresult ;
41840   Dali::PinchGestureDetector result;
41841
41842   {
41843     try {
41844       result = Dali::PinchGestureDetector::New();
41845     } catch (std::out_of_range& e) {
41846       {
41847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41848       };
41849     } catch (std::exception& e) {
41850       {
41851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41852       };
41853     } catch (Dali::DaliException e) {
41854       {
41855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41856       };
41857     } catch (...) {
41858       {
41859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41860       };
41861     }
41862   }
41863
41864   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41865   return jresult;
41866 }
41867
41868
41869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41870   void * jresult ;
41871   Dali::BaseHandle arg1 ;
41872   Dali::BaseHandle *argp1 ;
41873   Dali::PinchGestureDetector result;
41874
41875   argp1 = (Dali::BaseHandle *)jarg1;
41876   if (!argp1) {
41877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41878     return 0;
41879   }
41880   arg1 = *argp1;
41881   {
41882     try {
41883       result = Dali::PinchGestureDetector::DownCast(arg1);
41884     } catch (std::out_of_range& e) {
41885       {
41886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41887       };
41888     } catch (std::exception& e) {
41889       {
41890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41891       };
41892     } catch (Dali::DaliException e) {
41893       {
41894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41895       };
41896     } catch (...) {
41897       {
41898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41899       };
41900     }
41901   }
41902
41903   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41904   return jresult;
41905 }
41906
41907
41908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41909   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41910
41911   arg1 = (Dali::PinchGestureDetector *)jarg1;
41912   {
41913     try {
41914       delete arg1;
41915     } catch (std::out_of_range& e) {
41916       {
41917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41918       };
41919     } catch (std::exception& e) {
41920       {
41921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41922       };
41923     } catch (Dali::DaliException e) {
41924       {
41925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41926       };
41927     } catch (...) {
41928       {
41929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41930       };
41931     }
41932   }
41933
41934 }
41935
41936
41937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41938   void * jresult ;
41939   Dali::PinchGestureDetector *arg1 = 0 ;
41940   Dali::PinchGestureDetector *result = 0 ;
41941
41942   arg1 = (Dali::PinchGestureDetector *)jarg1;
41943   if (!arg1) {
41944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41945     return 0;
41946   }
41947   {
41948     try {
41949       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41950     } catch (std::out_of_range& e) {
41951       {
41952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41953       };
41954     } catch (std::exception& e) {
41955       {
41956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41957       };
41958     } catch (Dali::DaliException e) {
41959       {
41960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41961       };
41962     } catch (...) {
41963       {
41964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41965       };
41966     }
41967   }
41968
41969   jresult = (void *)result;
41970   return jresult;
41971 }
41972
41973
41974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41975   void * jresult ;
41976   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41977   Dali::PinchGestureDetector *arg2 = 0 ;
41978   Dali::PinchGestureDetector *result = 0 ;
41979
41980   arg1 = (Dali::PinchGestureDetector *)jarg1;
41981   arg2 = (Dali::PinchGestureDetector *)jarg2;
41982   if (!arg2) {
41983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41984     return 0;
41985   }
41986   {
41987     try {
41988       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41989     } catch (std::out_of_range& e) {
41990       {
41991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41992       };
41993     } catch (std::exception& e) {
41994       {
41995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41996       };
41997     } catch (Dali::DaliException e) {
41998       {
41999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42000       };
42001     } catch (...) {
42002       {
42003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42004       };
42005     }
42006   }
42007
42008   jresult = (void *)result;
42009   return jresult;
42010 }
42011
42012
42013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
42014   void * jresult ;
42015   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42016   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
42017
42018   arg1 = (Dali::PinchGestureDetector *)jarg1;
42019   {
42020     try {
42021       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42022     } catch (std::out_of_range& e) {
42023       {
42024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42025       };
42026     } catch (std::exception& e) {
42027       {
42028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42029       };
42030     } catch (Dali::DaliException e) {
42031       {
42032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42033       };
42034     } catch (...) {
42035       {
42036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42037       };
42038     }
42039   }
42040
42041   jresult = (void *)result;
42042   return jresult;
42043 }
42044
42045
42046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
42047   void * jresult ;
42048   Dali::Gesture::State arg1 ;
42049   Dali::PinchGesture *result = 0 ;
42050
42051   arg1 = (Dali::Gesture::State)jarg1;
42052   {
42053     try {
42054       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
42055     } catch (std::out_of_range& e) {
42056       {
42057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42058       };
42059     } catch (std::exception& e) {
42060       {
42061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42062       };
42063     } catch (Dali::DaliException e) {
42064       {
42065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42066       };
42067     } catch (...) {
42068       {
42069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42070       };
42071     }
42072   }
42073
42074   jresult = (void *)result;
42075   return jresult;
42076 }
42077
42078
42079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42080   void * jresult ;
42081   Dali::PinchGesture *arg1 = 0 ;
42082   Dali::PinchGesture *result = 0 ;
42083
42084   arg1 = (Dali::PinchGesture *)jarg1;
42085   if (!arg1) {
42086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42087     return 0;
42088   }
42089   {
42090     try {
42091       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42092     } catch (std::out_of_range& e) {
42093       {
42094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42095       };
42096     } catch (std::exception& e) {
42097       {
42098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42099       };
42100     } catch (Dali::DaliException e) {
42101       {
42102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42103       };
42104     } catch (...) {
42105       {
42106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42107       };
42108     }
42109   }
42110
42111   jresult = (void *)result;
42112   return jresult;
42113 }
42114
42115
42116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42117   void * jresult ;
42118   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42119   Dali::PinchGesture *arg2 = 0 ;
42120   Dali::PinchGesture *result = 0 ;
42121
42122   arg1 = (Dali::PinchGesture *)jarg1;
42123   arg2 = (Dali::PinchGesture *)jarg2;
42124   if (!arg2) {
42125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42126     return 0;
42127   }
42128   {
42129     try {
42130       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42131     } catch (std::out_of_range& e) {
42132       {
42133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42134       };
42135     } catch (std::exception& e) {
42136       {
42137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42138       };
42139     } catch (Dali::DaliException e) {
42140       {
42141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42142       };
42143     } catch (...) {
42144       {
42145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42146       };
42147     }
42148   }
42149
42150   jresult = (void *)result;
42151   return jresult;
42152 }
42153
42154
42155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42156   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42157
42158   arg1 = (Dali::PinchGesture *)jarg1;
42159   {
42160     try {
42161       delete arg1;
42162     } catch (std::out_of_range& e) {
42163       {
42164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42165       };
42166     } catch (std::exception& e) {
42167       {
42168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42169       };
42170     } catch (Dali::DaliException e) {
42171       {
42172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42173       };
42174     } catch (...) {
42175       {
42176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42177       };
42178     }
42179   }
42180
42181 }
42182
42183
42184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42185   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42186   float arg2 ;
42187
42188   arg1 = (Dali::PinchGesture *)jarg1;
42189   arg2 = (float)jarg2;
42190   if (arg1) (arg1)->scale = arg2;
42191 }
42192
42193
42194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42195   float jresult ;
42196   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42197   float result;
42198
42199   arg1 = (Dali::PinchGesture *)jarg1;
42200   result = (float) ((arg1)->scale);
42201   jresult = result;
42202   return jresult;
42203 }
42204
42205
42206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42207   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42208   float arg2 ;
42209
42210   arg1 = (Dali::PinchGesture *)jarg1;
42211   arg2 = (float)jarg2;
42212   if (arg1) (arg1)->speed = arg2;
42213 }
42214
42215
42216 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42217   float jresult ;
42218   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42219   float result;
42220
42221   arg1 = (Dali::PinchGesture *)jarg1;
42222   result = (float) ((arg1)->speed);
42223   jresult = result;
42224   return jresult;
42225 }
42226
42227
42228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42229   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42230   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42231
42232   arg1 = (Dali::PinchGesture *)jarg1;
42233   arg2 = (Dali::Vector2 *)jarg2;
42234   if (arg1) (arg1)->screenCenterPoint = *arg2;
42235 }
42236
42237
42238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42239   void * jresult ;
42240   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42241   Dali::Vector2 *result = 0 ;
42242
42243   arg1 = (Dali::PinchGesture *)jarg1;
42244   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42245   jresult = (void *)result;
42246   return jresult;
42247 }
42248
42249
42250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42251   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42252   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42253
42254   arg1 = (Dali::PinchGesture *)jarg1;
42255   arg2 = (Dali::Vector2 *)jarg2;
42256   if (arg1) (arg1)->localCenterPoint = *arg2;
42257 }
42258
42259
42260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42261   void * jresult ;
42262   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42263   Dali::Vector2 *result = 0 ;
42264
42265   arg1 = (Dali::PinchGesture *)jarg1;
42266   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42267   jresult = (void *)result;
42268   return jresult;
42269 }
42270
42271
42272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42273   void * jresult ;
42274   Dali::TapGestureDetector *result = 0 ;
42275
42276   {
42277     try {
42278       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42279     } catch (std::out_of_range& e) {
42280       {
42281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42282       };
42283     } catch (std::exception& e) {
42284       {
42285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42286       };
42287     } catch (Dali::DaliException e) {
42288       {
42289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42290       };
42291     } catch (...) {
42292       {
42293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42294       };
42295     }
42296   }
42297
42298   jresult = (void *)result;
42299   return jresult;
42300 }
42301
42302
42303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42304   void * jresult ;
42305   Dali::TapGestureDetector result;
42306
42307   {
42308     try {
42309       result = Dali::TapGestureDetector::New();
42310     } catch (std::out_of_range& e) {
42311       {
42312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42313       };
42314     } catch (std::exception& e) {
42315       {
42316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42317       };
42318     } catch (Dali::DaliException e) {
42319       {
42320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42321       };
42322     } catch (...) {
42323       {
42324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42325       };
42326     }
42327   }
42328
42329   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42330   return jresult;
42331 }
42332
42333
42334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42335   void * jresult ;
42336   unsigned int arg1 ;
42337   Dali::TapGestureDetector result;
42338
42339   arg1 = (unsigned int)jarg1;
42340   {
42341     try {
42342       result = Dali::TapGestureDetector::New(arg1);
42343     } catch (std::out_of_range& e) {
42344       {
42345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42346       };
42347     } catch (std::exception& e) {
42348       {
42349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42350       };
42351     } catch (Dali::DaliException e) {
42352       {
42353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42354       };
42355     } catch (...) {
42356       {
42357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42358       };
42359     }
42360   }
42361
42362   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42363   return jresult;
42364 }
42365
42366
42367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42368   void * jresult ;
42369   Dali::BaseHandle arg1 ;
42370   Dali::BaseHandle *argp1 ;
42371   Dali::TapGestureDetector result;
42372
42373   argp1 = (Dali::BaseHandle *)jarg1;
42374   if (!argp1) {
42375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42376     return 0;
42377   }
42378   arg1 = *argp1;
42379   {
42380     try {
42381       result = Dali::TapGestureDetector::DownCast(arg1);
42382     } catch (std::out_of_range& e) {
42383       {
42384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42385       };
42386     } catch (std::exception& e) {
42387       {
42388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42389       };
42390     } catch (Dali::DaliException e) {
42391       {
42392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42393       };
42394     } catch (...) {
42395       {
42396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42397       };
42398     }
42399   }
42400
42401   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42402   return jresult;
42403 }
42404
42405
42406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42407   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42408
42409   arg1 = (Dali::TapGestureDetector *)jarg1;
42410   {
42411     try {
42412       delete arg1;
42413     } catch (std::out_of_range& e) {
42414       {
42415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42416       };
42417     } catch (std::exception& e) {
42418       {
42419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42420       };
42421     } catch (Dali::DaliException e) {
42422       {
42423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42424       };
42425     } catch (...) {
42426       {
42427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42428       };
42429     }
42430   }
42431
42432 }
42433
42434
42435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42436   void * jresult ;
42437   Dali::TapGestureDetector *arg1 = 0 ;
42438   Dali::TapGestureDetector *result = 0 ;
42439
42440   arg1 = (Dali::TapGestureDetector *)jarg1;
42441   if (!arg1) {
42442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42443     return 0;
42444   }
42445   {
42446     try {
42447       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42448     } catch (std::out_of_range& e) {
42449       {
42450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42451       };
42452     } catch (std::exception& e) {
42453       {
42454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42455       };
42456     } catch (Dali::DaliException e) {
42457       {
42458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42459       };
42460     } catch (...) {
42461       {
42462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42463       };
42464     }
42465   }
42466
42467   jresult = (void *)result;
42468   return jresult;
42469 }
42470
42471
42472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42473   void * jresult ;
42474   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42475   Dali::TapGestureDetector *arg2 = 0 ;
42476   Dali::TapGestureDetector *result = 0 ;
42477
42478   arg1 = (Dali::TapGestureDetector *)jarg1;
42479   arg2 = (Dali::TapGestureDetector *)jarg2;
42480   if (!arg2) {
42481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42482     return 0;
42483   }
42484   {
42485     try {
42486       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42487     } catch (std::out_of_range& e) {
42488       {
42489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42490       };
42491     } catch (std::exception& e) {
42492       {
42493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42494       };
42495     } catch (Dali::DaliException e) {
42496       {
42497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42498       };
42499     } catch (...) {
42500       {
42501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42502       };
42503     }
42504   }
42505
42506   jresult = (void *)result;
42507   return jresult;
42508 }
42509
42510
42511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42512   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42513   unsigned int arg2 ;
42514
42515   arg1 = (Dali::TapGestureDetector *)jarg1;
42516   arg2 = (unsigned int)jarg2;
42517   {
42518     try {
42519       (arg1)->SetMinimumTapsRequired(arg2);
42520     } catch (std::out_of_range& e) {
42521       {
42522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42523       };
42524     } catch (std::exception& e) {
42525       {
42526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42527       };
42528     } catch (Dali::DaliException e) {
42529       {
42530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42531       };
42532     } catch (...) {
42533       {
42534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42535       };
42536     }
42537   }
42538
42539 }
42540
42541
42542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42543   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42544   unsigned int arg2 ;
42545
42546   arg1 = (Dali::TapGestureDetector *)jarg1;
42547   arg2 = (unsigned int)jarg2;
42548   {
42549     try {
42550       (arg1)->SetMaximumTapsRequired(arg2);
42551     } catch (std::out_of_range& e) {
42552       {
42553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42554       };
42555     } catch (std::exception& e) {
42556       {
42557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42558       };
42559     } catch (Dali::DaliException e) {
42560       {
42561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42562       };
42563     } catch (...) {
42564       {
42565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42566       };
42567     }
42568   }
42569
42570 }
42571
42572
42573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42574   unsigned int jresult ;
42575   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42576   unsigned int result;
42577
42578   arg1 = (Dali::TapGestureDetector *)jarg1;
42579   {
42580     try {
42581       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42582     } catch (std::out_of_range& e) {
42583       {
42584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42585       };
42586     } catch (std::exception& e) {
42587       {
42588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42589       };
42590     } catch (Dali::DaliException e) {
42591       {
42592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42593       };
42594     } catch (...) {
42595       {
42596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42597       };
42598     }
42599   }
42600
42601   jresult = result;
42602   return jresult;
42603 }
42604
42605
42606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42607   unsigned int jresult ;
42608   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42609   unsigned int result;
42610
42611   arg1 = (Dali::TapGestureDetector *)jarg1;
42612   {
42613     try {
42614       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42615     } catch (std::out_of_range& e) {
42616       {
42617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42618       };
42619     } catch (std::exception& e) {
42620       {
42621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42622       };
42623     } catch (Dali::DaliException e) {
42624       {
42625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42626       };
42627     } catch (...) {
42628       {
42629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42630       };
42631     }
42632   }
42633
42634   jresult = result;
42635   return jresult;
42636 }
42637
42638
42639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42640   void * jresult ;
42641   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42642   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42643
42644   arg1 = (Dali::TapGestureDetector *)jarg1;
42645   {
42646     try {
42647       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42648     } catch (std::out_of_range& e) {
42649       {
42650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42651       };
42652     } catch (std::exception& e) {
42653       {
42654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42655       };
42656     } catch (Dali::DaliException e) {
42657       {
42658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42659       };
42660     } catch (...) {
42661       {
42662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42663       };
42664     }
42665   }
42666
42667   jresult = (void *)result;
42668   return jresult;
42669 }
42670
42671
42672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42673   void * jresult ;
42674   Dali::TapGesture *result = 0 ;
42675
42676   {
42677     try {
42678       result = (Dali::TapGesture *)new Dali::TapGesture();
42679     } catch (std::out_of_range& e) {
42680       {
42681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42682       };
42683     } catch (std::exception& e) {
42684       {
42685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42686       };
42687     } catch (Dali::DaliException e) {
42688       {
42689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42690       };
42691     } catch (...) {
42692       {
42693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42694       };
42695     }
42696   }
42697
42698   jresult = (void *)result;
42699   return jresult;
42700 }
42701
42702
42703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42704   void * jresult ;
42705   Dali::TapGesture *arg1 = 0 ;
42706   Dali::TapGesture *result = 0 ;
42707
42708   arg1 = (Dali::TapGesture *)jarg1;
42709   if (!arg1) {
42710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42711     return 0;
42712   }
42713   {
42714     try {
42715       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42716     } catch (std::out_of_range& e) {
42717       {
42718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42719       };
42720     } catch (std::exception& e) {
42721       {
42722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42723       };
42724     } catch (Dali::DaliException e) {
42725       {
42726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42727       };
42728     } catch (...) {
42729       {
42730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42731       };
42732     }
42733   }
42734
42735   jresult = (void *)result;
42736   return jresult;
42737 }
42738
42739
42740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42741   void * jresult ;
42742   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42743   Dali::TapGesture *arg2 = 0 ;
42744   Dali::TapGesture *result = 0 ;
42745
42746   arg1 = (Dali::TapGesture *)jarg1;
42747   arg2 = (Dali::TapGesture *)jarg2;
42748   if (!arg2) {
42749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42750     return 0;
42751   }
42752   {
42753     try {
42754       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42755     } catch (std::out_of_range& e) {
42756       {
42757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42758       };
42759     } catch (std::exception& e) {
42760       {
42761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42762       };
42763     } catch (Dali::DaliException e) {
42764       {
42765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42766       };
42767     } catch (...) {
42768       {
42769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42770       };
42771     }
42772   }
42773
42774   jresult = (void *)result;
42775   return jresult;
42776 }
42777
42778
42779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42780   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42781
42782   arg1 = (Dali::TapGesture *)jarg1;
42783   {
42784     try {
42785       delete arg1;
42786     } catch (std::out_of_range& e) {
42787       {
42788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42789       };
42790     } catch (std::exception& e) {
42791       {
42792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42793       };
42794     } catch (Dali::DaliException e) {
42795       {
42796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42797       };
42798     } catch (...) {
42799       {
42800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42801       };
42802     }
42803   }
42804
42805 }
42806
42807
42808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42809   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42810   unsigned int arg2 ;
42811
42812   arg1 = (Dali::TapGesture *)jarg1;
42813   arg2 = (unsigned int)jarg2;
42814   if (arg1) (arg1)->numberOfTaps = arg2;
42815 }
42816
42817
42818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42819   unsigned int jresult ;
42820   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42821   unsigned int result;
42822
42823   arg1 = (Dali::TapGesture *)jarg1;
42824   result = (unsigned int) ((arg1)->numberOfTaps);
42825   jresult = result;
42826   return jresult;
42827 }
42828
42829
42830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42831   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42832   unsigned int arg2 ;
42833
42834   arg1 = (Dali::TapGesture *)jarg1;
42835   arg2 = (unsigned int)jarg2;
42836   if (arg1) (arg1)->numberOfTouches = arg2;
42837 }
42838
42839
42840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42841   unsigned int jresult ;
42842   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42843   unsigned int result;
42844
42845   arg1 = (Dali::TapGesture *)jarg1;
42846   result = (unsigned int) ((arg1)->numberOfTouches);
42847   jresult = result;
42848   return jresult;
42849 }
42850
42851
42852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42853   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42854   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42855
42856   arg1 = (Dali::TapGesture *)jarg1;
42857   arg2 = (Dali::Vector2 *)jarg2;
42858   if (arg1) (arg1)->screenPoint = *arg2;
42859 }
42860
42861
42862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42863   void * jresult ;
42864   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42865   Dali::Vector2 *result = 0 ;
42866
42867   arg1 = (Dali::TapGesture *)jarg1;
42868   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42869   jresult = (void *)result;
42870   return jresult;
42871 }
42872
42873
42874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42875   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42876   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42877
42878   arg1 = (Dali::TapGesture *)jarg1;
42879   arg2 = (Dali::Vector2 *)jarg2;
42880   if (arg1) (arg1)->localPoint = *arg2;
42881 }
42882
42883
42884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42885   void * jresult ;
42886   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42887   Dali::Vector2 *result = 0 ;
42888
42889   arg1 = (Dali::TapGesture *)jarg1;
42890   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42891   jresult = (void *)result;
42892   return jresult;
42893 }
42894
42895
42896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42897   void * jresult ;
42898   Dali::AlphaFunction *result = 0 ;
42899
42900   {
42901     try {
42902       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42903     } catch (std::out_of_range& e) {
42904       {
42905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42906       };
42907     } catch (std::exception& e) {
42908       {
42909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42910       };
42911     } catch (Dali::DaliException e) {
42912       {
42913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42914       };
42915     } catch (...) {
42916       {
42917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42918       };
42919     }
42920   }
42921
42922   jresult = (void *)result;
42923   return jresult;
42924 }
42925
42926
42927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42928   void * jresult ;
42929   Dali::AlphaFunction::BuiltinFunction arg1 ;
42930   Dali::AlphaFunction *result = 0 ;
42931
42932   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42933   {
42934     try {
42935       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42936     } catch (std::out_of_range& e) {
42937       {
42938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42939       };
42940     } catch (std::exception& e) {
42941       {
42942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42943       };
42944     } catch (Dali::DaliException e) {
42945       {
42946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42947       };
42948     } catch (...) {
42949       {
42950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42951       };
42952     }
42953   }
42954
42955   jresult = (void *)result;
42956   return jresult;
42957 }
42958
42959
42960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42961   void * jresult ;
42962   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42963   Dali::AlphaFunction *result = 0 ;
42964
42965   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42966   {
42967     try {
42968       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42969     } catch (std::out_of_range& e) {
42970       {
42971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42972       };
42973     } catch (std::exception& e) {
42974       {
42975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42976       };
42977     } catch (Dali::DaliException e) {
42978       {
42979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42980       };
42981     } catch (...) {
42982       {
42983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42984       };
42985     }
42986   }
42987
42988   jresult = (void *)result;
42989   return jresult;
42990 }
42991
42992
42993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42994   void * jresult ;
42995   Dali::Vector2 *arg1 = 0 ;
42996   Dali::Vector2 *arg2 = 0 ;
42997   Dali::AlphaFunction *result = 0 ;
42998
42999   arg1 = (Dali::Vector2 *)jarg1;
43000   if (!arg1) {
43001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43002     return 0;
43003   }
43004   arg2 = (Dali::Vector2 *)jarg2;
43005   if (!arg2) {
43006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43007     return 0;
43008   }
43009   {
43010     try {
43011       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
43012     } catch (std::out_of_range& e) {
43013       {
43014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43015       };
43016     } catch (std::exception& e) {
43017       {
43018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43019       };
43020     } catch (Dali::DaliException e) {
43021       {
43022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43023       };
43024     } catch (...) {
43025       {
43026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43027       };
43028     }
43029   }
43030
43031   jresult = (void *)result;
43032   return jresult;
43033 }
43034
43035
43036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
43037   void * jresult ;
43038   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43039   Dali::Vector4 result;
43040
43041   arg1 = (Dali::AlphaFunction *)jarg1;
43042   {
43043     try {
43044       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
43045     } catch (std::out_of_range& e) {
43046       {
43047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43048       };
43049     } catch (std::exception& e) {
43050       {
43051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43052       };
43053     } catch (Dali::DaliException e) {
43054       {
43055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43056       };
43057     } catch (...) {
43058       {
43059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43060       };
43061     }
43062   }
43063
43064   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43065   return jresult;
43066 }
43067
43068
43069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43070   void * jresult ;
43071   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43072   Dali::AlphaFunctionPrototype result;
43073
43074   arg1 = (Dali::AlphaFunction *)jarg1;
43075   {
43076     try {
43077       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
43078     } catch (std::out_of_range& e) {
43079       {
43080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43081       };
43082     } catch (std::exception& e) {
43083       {
43084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43085       };
43086     } catch (Dali::DaliException e) {
43087       {
43088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43089       };
43090     } catch (...) {
43091       {
43092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43093       };
43094     }
43095   }
43096
43097   jresult = (void *)result;
43098   return jresult;
43099 }
43100
43101
43102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43103   int jresult ;
43104   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43105   Dali::AlphaFunction::BuiltinFunction result;
43106
43107   arg1 = (Dali::AlphaFunction *)jarg1;
43108   {
43109     try {
43110       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43111     } catch (std::out_of_range& e) {
43112       {
43113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43114       };
43115     } catch (std::exception& e) {
43116       {
43117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43118       };
43119     } catch (Dali::DaliException e) {
43120       {
43121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43122       };
43123     } catch (...) {
43124       {
43125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43126       };
43127     }
43128   }
43129
43130   jresult = (int)result;
43131   return jresult;
43132 }
43133
43134
43135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43136   int jresult ;
43137   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43138   Dali::AlphaFunction::Mode result;
43139
43140   arg1 = (Dali::AlphaFunction *)jarg1;
43141   {
43142     try {
43143       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43144     } catch (std::out_of_range& e) {
43145       {
43146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43147       };
43148     } catch (std::exception& e) {
43149       {
43150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43151       };
43152     } catch (Dali::DaliException e) {
43153       {
43154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43155       };
43156     } catch (...) {
43157       {
43158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43159       };
43160     }
43161   }
43162
43163   jresult = (int)result;
43164   return jresult;
43165 }
43166
43167
43168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43169   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43170
43171   arg1 = (Dali::AlphaFunction *)jarg1;
43172   {
43173     try {
43174       delete arg1;
43175     } catch (std::out_of_range& e) {
43176       {
43177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43178       };
43179     } catch (std::exception& e) {
43180       {
43181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43182       };
43183     } catch (Dali::DaliException e) {
43184       {
43185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43186       };
43187     } catch (...) {
43188       {
43189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43190       };
43191     }
43192   }
43193
43194 }
43195
43196
43197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43198   void * jresult ;
43199   Dali::KeyFrames result;
43200
43201   {
43202     try {
43203       result = Dali::KeyFrames::New();
43204     } catch (std::out_of_range& e) {
43205       {
43206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43207       };
43208     } catch (std::exception& e) {
43209       {
43210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43211       };
43212     } catch (Dali::DaliException e) {
43213       {
43214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43215       };
43216     } catch (...) {
43217       {
43218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43219       };
43220     }
43221   }
43222
43223   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43224   return jresult;
43225 }
43226
43227
43228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43229   void * jresult ;
43230   Dali::BaseHandle arg1 ;
43231   Dali::BaseHandle *argp1 ;
43232   Dali::KeyFrames result;
43233
43234   argp1 = (Dali::BaseHandle *)jarg1;
43235   if (!argp1) {
43236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43237     return 0;
43238   }
43239   arg1 = *argp1;
43240   {
43241     try {
43242       result = Dali::KeyFrames::DownCast(arg1);
43243     } catch (std::out_of_range& e) {
43244       {
43245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43246       };
43247     } catch (std::exception& e) {
43248       {
43249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43250       };
43251     } catch (Dali::DaliException e) {
43252       {
43253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43254       };
43255     } catch (...) {
43256       {
43257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43258       };
43259     }
43260   }
43261
43262   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43263   return jresult;
43264 }
43265
43266
43267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43268   void * jresult ;
43269   Dali::KeyFrames *result = 0 ;
43270
43271   {
43272     try {
43273       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43274     } catch (std::out_of_range& e) {
43275       {
43276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43277       };
43278     } catch (std::exception& e) {
43279       {
43280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43281       };
43282     } catch (Dali::DaliException e) {
43283       {
43284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43285       };
43286     } catch (...) {
43287       {
43288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43289       };
43290     }
43291   }
43292
43293   jresult = (void *)result;
43294   return jresult;
43295 }
43296
43297
43298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43299   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43300
43301   arg1 = (Dali::KeyFrames *)jarg1;
43302   {
43303     try {
43304       delete arg1;
43305     } catch (std::out_of_range& e) {
43306       {
43307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43308       };
43309     } catch (std::exception& e) {
43310       {
43311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43312       };
43313     } catch (Dali::DaliException e) {
43314       {
43315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43316       };
43317     } catch (...) {
43318       {
43319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43320       };
43321     }
43322   }
43323
43324 }
43325
43326
43327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43328   void * jresult ;
43329   Dali::KeyFrames *arg1 = 0 ;
43330   Dali::KeyFrames *result = 0 ;
43331
43332   arg1 = (Dali::KeyFrames *)jarg1;
43333   if (!arg1) {
43334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43335     return 0;
43336   }
43337   {
43338     try {
43339       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43340     } catch (std::out_of_range& e) {
43341       {
43342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43343       };
43344     } catch (std::exception& e) {
43345       {
43346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43347       };
43348     } catch (Dali::DaliException e) {
43349       {
43350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43351       };
43352     } catch (...) {
43353       {
43354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43355       };
43356     }
43357   }
43358
43359   jresult = (void *)result;
43360   return jresult;
43361 }
43362
43363
43364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43365   void * jresult ;
43366   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43367   Dali::KeyFrames *arg2 = 0 ;
43368   Dali::KeyFrames *result = 0 ;
43369
43370   arg1 = (Dali::KeyFrames *)jarg1;
43371   arg2 = (Dali::KeyFrames *)jarg2;
43372   if (!arg2) {
43373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43374     return 0;
43375   }
43376   {
43377     try {
43378       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43379     } catch (std::out_of_range& e) {
43380       {
43381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43382       };
43383     } catch (std::exception& e) {
43384       {
43385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43386       };
43387     } catch (Dali::DaliException e) {
43388       {
43389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43390       };
43391     } catch (...) {
43392       {
43393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43394       };
43395     }
43396   }
43397
43398   jresult = (void *)result;
43399   return jresult;
43400 }
43401
43402
43403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43404   int jresult ;
43405   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43406   Dali::Property::Type result;
43407
43408   arg1 = (Dali::KeyFrames *)jarg1;
43409   {
43410     try {
43411       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43412     } catch (std::out_of_range& e) {
43413       {
43414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43415       };
43416     } catch (std::exception& e) {
43417       {
43418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43419       };
43420     } catch (Dali::DaliException e) {
43421       {
43422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43423       };
43424     } catch (...) {
43425       {
43426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43427       };
43428     }
43429   }
43430
43431   jresult = (int)result;
43432   return jresult;
43433 }
43434
43435
43436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43437   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43438   float arg2 ;
43439   Dali::Property::Value arg3 ;
43440   Dali::Property::Value *argp3 ;
43441
43442   arg1 = (Dali::KeyFrames *)jarg1;
43443   arg2 = (float)jarg2;
43444   argp3 = (Dali::Property::Value *)jarg3;
43445   if (!argp3) {
43446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43447     return ;
43448   }
43449   arg3 = *argp3;
43450   {
43451     try {
43452       (arg1)->Add(arg2,arg3);
43453     } catch (std::out_of_range& e) {
43454       {
43455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43456       };
43457     } catch (std::exception& e) {
43458       {
43459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43460       };
43461     } catch (Dali::DaliException e) {
43462       {
43463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43464       };
43465     } catch (...) {
43466       {
43467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43468       };
43469     }
43470   }
43471
43472 }
43473
43474
43475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43476   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43477   float arg2 ;
43478   Dali::Property::Value arg3 ;
43479   Dali::AlphaFunction arg4 ;
43480   Dali::Property::Value *argp3 ;
43481   Dali::AlphaFunction *argp4 ;
43482
43483   arg1 = (Dali::KeyFrames *)jarg1;
43484   arg2 = (float)jarg2;
43485   argp3 = (Dali::Property::Value *)jarg3;
43486   if (!argp3) {
43487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43488     return ;
43489   }
43490   arg3 = *argp3;
43491   argp4 = (Dali::AlphaFunction *)jarg4;
43492   if (!argp4) {
43493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43494     return ;
43495   }
43496   arg4 = *argp4;
43497   {
43498     try {
43499       (arg1)->Add(arg2,arg3,arg4);
43500     } catch (std::out_of_range& e) {
43501       {
43502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43503       };
43504     } catch (std::exception& e) {
43505       {
43506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43507       };
43508     } catch (Dali::DaliException e) {
43509       {
43510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43511       };
43512     } catch (...) {
43513       {
43514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43515       };
43516     }
43517   }
43518
43519 }
43520
43521
43522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43523   int jresult ;
43524   int result;
43525
43526   result = (int)Dali::Path::Property::POINTS;
43527   jresult = (int)result;
43528   return jresult;
43529 }
43530
43531
43532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43533   int jresult ;
43534   int result;
43535
43536   result = (int)Dali::Path::Property::CONTROL_POINTS;
43537   jresult = (int)result;
43538   return jresult;
43539 }
43540
43541
43542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43543   void * jresult ;
43544   Dali::Path::Property *result = 0 ;
43545
43546   {
43547     try {
43548       result = (Dali::Path::Property *)new Dali::Path::Property();
43549     } catch (std::out_of_range& e) {
43550       {
43551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43552       };
43553     } catch (std::exception& e) {
43554       {
43555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43556       };
43557     } catch (Dali::DaliException e) {
43558       {
43559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43560       };
43561     } catch (...) {
43562       {
43563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43564       };
43565     }
43566   }
43567
43568   jresult = (void *)result;
43569   return jresult;
43570 }
43571
43572
43573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43574   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43575
43576   arg1 = (Dali::Path::Property *)jarg1;
43577   {
43578     try {
43579       delete arg1;
43580     } catch (std::out_of_range& e) {
43581       {
43582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43583       };
43584     } catch (std::exception& e) {
43585       {
43586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43587       };
43588     } catch (Dali::DaliException e) {
43589       {
43590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43591       };
43592     } catch (...) {
43593       {
43594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43595       };
43596     }
43597   }
43598
43599 }
43600
43601
43602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43603   void * jresult ;
43604   Dali::Path result;
43605
43606   {
43607     try {
43608       result = Dali::Path::New();
43609     } catch (std::out_of_range& e) {
43610       {
43611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43612       };
43613     } catch (std::exception& e) {
43614       {
43615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43616       };
43617     } catch (Dali::DaliException e) {
43618       {
43619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43620       };
43621     } catch (...) {
43622       {
43623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43624       };
43625     }
43626   }
43627
43628   jresult = new Dali::Path((const Dali::Path &)result);
43629   return jresult;
43630 }
43631
43632
43633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43634   void * jresult ;
43635   Dali::BaseHandle arg1 ;
43636   Dali::BaseHandle *argp1 ;
43637   Dali::Path result;
43638
43639   argp1 = (Dali::BaseHandle *)jarg1;
43640   if (!argp1) {
43641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43642     return 0;
43643   }
43644   arg1 = *argp1;
43645   {
43646     try {
43647       result = Dali::Path::DownCast(arg1);
43648     } catch (std::out_of_range& e) {
43649       {
43650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43651       };
43652     } catch (std::exception& e) {
43653       {
43654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43655       };
43656     } catch (Dali::DaliException e) {
43657       {
43658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43659       };
43660     } catch (...) {
43661       {
43662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43663       };
43664     }
43665   }
43666
43667   jresult = new Dali::Path((const Dali::Path &)result);
43668   return jresult;
43669 }
43670
43671
43672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43673   void * jresult ;
43674   Dali::Path *result = 0 ;
43675
43676   {
43677     try {
43678       result = (Dali::Path *)new Dali::Path();
43679     } catch (std::out_of_range& e) {
43680       {
43681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43682       };
43683     } catch (std::exception& e) {
43684       {
43685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43686       };
43687     } catch (Dali::DaliException e) {
43688       {
43689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43690       };
43691     } catch (...) {
43692       {
43693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43694       };
43695     }
43696   }
43697
43698   jresult = (void *)result;
43699   return jresult;
43700 }
43701
43702
43703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43704   Dali::Path *arg1 = (Dali::Path *) 0 ;
43705
43706   arg1 = (Dali::Path *)jarg1;
43707   {
43708     try {
43709       delete arg1;
43710     } catch (std::out_of_range& e) {
43711       {
43712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43713       };
43714     } catch (std::exception& e) {
43715       {
43716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43717       };
43718     } catch (Dali::DaliException e) {
43719       {
43720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43721       };
43722     } catch (...) {
43723       {
43724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43725       };
43726     }
43727   }
43728
43729 }
43730
43731
43732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43733   void * jresult ;
43734   Dali::Path *arg1 = 0 ;
43735   Dali::Path *result = 0 ;
43736
43737   arg1 = (Dali::Path *)jarg1;
43738   if (!arg1) {
43739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43740     return 0;
43741   }
43742   {
43743     try {
43744       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43745     } catch (std::out_of_range& e) {
43746       {
43747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43748       };
43749     } catch (std::exception& e) {
43750       {
43751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43752       };
43753     } catch (Dali::DaliException e) {
43754       {
43755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43756       };
43757     } catch (...) {
43758       {
43759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43760       };
43761     }
43762   }
43763
43764   jresult = (void *)result;
43765   return jresult;
43766 }
43767
43768
43769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43770   void * jresult ;
43771   Dali::Path *arg1 = (Dali::Path *) 0 ;
43772   Dali::Path *arg2 = 0 ;
43773   Dali::Path *result = 0 ;
43774
43775   arg1 = (Dali::Path *)jarg1;
43776   arg2 = (Dali::Path *)jarg2;
43777   if (!arg2) {
43778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43779     return 0;
43780   }
43781   {
43782     try {
43783       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43784     } catch (std::out_of_range& e) {
43785       {
43786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43787       };
43788     } catch (std::exception& e) {
43789       {
43790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43791       };
43792     } catch (Dali::DaliException e) {
43793       {
43794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43795       };
43796     } catch (...) {
43797       {
43798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43799       };
43800     }
43801   }
43802
43803   jresult = (void *)result;
43804   return jresult;
43805 }
43806
43807
43808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43809   Dali::Path *arg1 = (Dali::Path *) 0 ;
43810   Dali::Vector3 *arg2 = 0 ;
43811
43812   arg1 = (Dali::Path *)jarg1;
43813   arg2 = (Dali::Vector3 *)jarg2;
43814   if (!arg2) {
43815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43816     return ;
43817   }
43818   {
43819     try {
43820       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43821     } catch (std::out_of_range& e) {
43822       {
43823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43824       };
43825     } catch (std::exception& e) {
43826       {
43827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43828       };
43829     } catch (Dali::DaliException e) {
43830       {
43831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43832       };
43833     } catch (...) {
43834       {
43835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43836       };
43837     }
43838   }
43839
43840 }
43841
43842
43843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43844   Dali::Path *arg1 = (Dali::Path *) 0 ;
43845   Dali::Vector3 *arg2 = 0 ;
43846
43847   arg1 = (Dali::Path *)jarg1;
43848   arg2 = (Dali::Vector3 *)jarg2;
43849   if (!arg2) {
43850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43851     return ;
43852   }
43853   {
43854     try {
43855       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43856     } catch (std::out_of_range& e) {
43857       {
43858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43859       };
43860     } catch (std::exception& e) {
43861       {
43862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43863       };
43864     } catch (Dali::DaliException e) {
43865       {
43866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43867       };
43868     } catch (...) {
43869       {
43870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43871       };
43872     }
43873   }
43874
43875 }
43876
43877
43878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43879   Dali::Path *arg1 = (Dali::Path *) 0 ;
43880   float arg2 ;
43881
43882   arg1 = (Dali::Path *)jarg1;
43883   arg2 = (float)jarg2;
43884   {
43885     try {
43886       (arg1)->GenerateControlPoints(arg2);
43887     } catch (std::out_of_range& e) {
43888       {
43889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43890       };
43891     } catch (std::exception& e) {
43892       {
43893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43894       };
43895     } catch (Dali::DaliException e) {
43896       {
43897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43898       };
43899     } catch (...) {
43900       {
43901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43902       };
43903     }
43904   }
43905
43906 }
43907
43908
43909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43910   Dali::Path *arg1 = (Dali::Path *) 0 ;
43911   float arg2 ;
43912   Dali::Vector3 *arg3 = 0 ;
43913   Dali::Vector3 *arg4 = 0 ;
43914
43915   arg1 = (Dali::Path *)jarg1;
43916   arg2 = (float)jarg2;
43917   arg3 = (Dali::Vector3 *)jarg3;
43918   if (!arg3) {
43919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43920     return ;
43921   }
43922   arg4 = (Dali::Vector3 *)jarg4;
43923   if (!arg4) {
43924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43925     return ;
43926   }
43927   {
43928     try {
43929       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43930     } catch (std::out_of_range& e) {
43931       {
43932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43933       };
43934     } catch (std::exception& e) {
43935       {
43936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43937       };
43938     } catch (Dali::DaliException e) {
43939       {
43940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43941       };
43942     } catch (...) {
43943       {
43944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43945       };
43946     }
43947   }
43948
43949 }
43950
43951
43952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43953   void * jresult ;
43954   Dali::Path *arg1 = (Dali::Path *) 0 ;
43955   size_t arg2 ;
43956   Dali::Vector3 *result = 0 ;
43957
43958   arg1 = (Dali::Path *)jarg1;
43959   arg2 = (size_t)jarg2;
43960   {
43961     try {
43962       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43963     } catch (std::out_of_range& e) {
43964       {
43965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43966       };
43967     } catch (std::exception& e) {
43968       {
43969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43970       };
43971     } catch (Dali::DaliException e) {
43972       {
43973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43974       };
43975     } catch (...) {
43976       {
43977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43978       };
43979     }
43980   }
43981
43982   jresult = (void *)result;
43983   return jresult;
43984 }
43985
43986
43987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43988   void * jresult ;
43989   Dali::Path *arg1 = (Dali::Path *) 0 ;
43990   size_t arg2 ;
43991   Dali::Vector3 *result = 0 ;
43992
43993   arg1 = (Dali::Path *)jarg1;
43994   arg2 = (size_t)jarg2;
43995   {
43996     try {
43997       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43998     } catch (std::out_of_range& e) {
43999       {
44000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44001       };
44002     } catch (std::exception& e) {
44003       {
44004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44005       };
44006     } catch (Dali::DaliException e) {
44007       {
44008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44009       };
44010     } catch (...) {
44011       {
44012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44013       };
44014     }
44015   }
44016
44017   jresult = (void *)result;
44018   return jresult;
44019 }
44020
44021
44022 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
44023   unsigned long jresult ;
44024   Dali::Path *arg1 = (Dali::Path *) 0 ;
44025   size_t result;
44026
44027   arg1 = (Dali::Path *)jarg1;
44028   {
44029     try {
44030       result = ((Dali::Path const *)arg1)->GetPointCount();
44031     } catch (std::out_of_range& e) {
44032       {
44033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44034       };
44035     } catch (std::exception& e) {
44036       {
44037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44038       };
44039     } catch (Dali::DaliException e) {
44040       {
44041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44042       };
44043     } catch (...) {
44044       {
44045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44046       };
44047     }
44048   }
44049
44050   jresult = (unsigned long)result;
44051   return jresult;
44052 }
44053
44054
44055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
44056   void * jresult ;
44057   float arg1 ;
44058   Dali::TimePeriod *result = 0 ;
44059
44060   arg1 = (float)jarg1;
44061   {
44062     try {
44063       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44064     } catch (std::out_of_range& e) {
44065       {
44066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44067       };
44068     } catch (std::exception& e) {
44069       {
44070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44071       };
44072     } catch (Dali::DaliException e) {
44073       {
44074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44075       };
44076     } catch (...) {
44077       {
44078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44079       };
44080     }
44081   }
44082
44083   jresult = (void *)result;
44084   return jresult;
44085 }
44086
44087
44088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44089   void * jresult ;
44090   float arg1 ;
44091   float arg2 ;
44092   Dali::TimePeriod *result = 0 ;
44093
44094   arg1 = (float)jarg1;
44095   arg2 = (float)jarg2;
44096   {
44097     try {
44098       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44099     } catch (std::out_of_range& e) {
44100       {
44101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44102       };
44103     } catch (std::exception& e) {
44104       {
44105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44106       };
44107     } catch (Dali::DaliException e) {
44108       {
44109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44110       };
44111     } catch (...) {
44112       {
44113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44114       };
44115     }
44116   }
44117
44118   jresult = (void *)result;
44119   return jresult;
44120 }
44121
44122
44123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44124   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44125
44126   arg1 = (Dali::TimePeriod *)jarg1;
44127   {
44128     try {
44129       delete arg1;
44130     } catch (std::out_of_range& e) {
44131       {
44132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44133       };
44134     } catch (std::exception& e) {
44135       {
44136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44137       };
44138     } catch (Dali::DaliException e) {
44139       {
44140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44141       };
44142     } catch (...) {
44143       {
44144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44145       };
44146     }
44147   }
44148
44149 }
44150
44151
44152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44153   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44154   float arg2 ;
44155
44156   arg1 = (Dali::TimePeriod *)jarg1;
44157   arg2 = (float)jarg2;
44158   if (arg1) (arg1)->delaySeconds = arg2;
44159 }
44160
44161
44162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44163   float jresult ;
44164   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44165   float result;
44166
44167   arg1 = (Dali::TimePeriod *)jarg1;
44168   result = (float) ((arg1)->delaySeconds);
44169   jresult = result;
44170   return jresult;
44171 }
44172
44173
44174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44175   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44176   float arg2 ;
44177
44178   arg1 = (Dali::TimePeriod *)jarg1;
44179   arg2 = (float)jarg2;
44180   if (arg1) (arg1)->durationSeconds = arg2;
44181 }
44182
44183
44184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44185   float jresult ;
44186   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44187   float result;
44188
44189   arg1 = (Dali::TimePeriod *)jarg1;
44190   result = (float) ((arg1)->durationSeconds);
44191   jresult = result;
44192   return jresult;
44193 }
44194
44195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44196   int jresult ;
44197   int result;
44198
44199   result = (int)Dali::LinearConstrainer::Property::VALUE;
44200   jresult = (int)result;
44201   return jresult;
44202 }
44203
44204
44205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44206   int jresult ;
44207   int result;
44208
44209   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44210   jresult = (int)result;
44211   return jresult;
44212 }
44213
44214
44215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44216   void * jresult ;
44217   Dali::LinearConstrainer::Property *result = 0 ;
44218
44219   {
44220     try {
44221       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44222     } catch (std::out_of_range& e) {
44223       {
44224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44225       };
44226     } catch (std::exception& e) {
44227       {
44228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44229       };
44230     } catch (Dali::DaliException e) {
44231       {
44232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44233       };
44234     } catch (...) {
44235       {
44236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44237       };
44238     }
44239   }
44240
44241   jresult = (void *)result;
44242   return jresult;
44243 }
44244
44245
44246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44247   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44248
44249   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44250   {
44251     try {
44252       delete arg1;
44253     } catch (std::out_of_range& e) {
44254       {
44255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44256       };
44257     } catch (std::exception& e) {
44258       {
44259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44260       };
44261     } catch (Dali::DaliException e) {
44262       {
44263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44264       };
44265     } catch (...) {
44266       {
44267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44268       };
44269     }
44270   }
44271
44272 }
44273
44274
44275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44276   void * jresult ;
44277   Dali::LinearConstrainer result;
44278
44279   {
44280     try {
44281       result = Dali::LinearConstrainer::New();
44282     } catch (std::out_of_range& e) {
44283       {
44284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44285       };
44286     } catch (std::exception& e) {
44287       {
44288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44289       };
44290     } catch (Dali::DaliException e) {
44291       {
44292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44293       };
44294     } catch (...) {
44295       {
44296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44297       };
44298     }
44299   }
44300
44301   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44302   return jresult;
44303 }
44304
44305
44306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44307   void * jresult ;
44308   Dali::BaseHandle arg1 ;
44309   Dali::BaseHandle *argp1 ;
44310   Dali::LinearConstrainer result;
44311
44312   argp1 = (Dali::BaseHandle *)jarg1;
44313   if (!argp1) {
44314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44315     return 0;
44316   }
44317   arg1 = *argp1;
44318   {
44319     try {
44320       result = Dali::LinearConstrainer::DownCast(arg1);
44321     } catch (std::out_of_range& e) {
44322       {
44323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44324       };
44325     } catch (std::exception& e) {
44326       {
44327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44328       };
44329     } catch (Dali::DaliException e) {
44330       {
44331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44332       };
44333     } catch (...) {
44334       {
44335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44336       };
44337     }
44338   }
44339
44340   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44341   return jresult;
44342 }
44343
44344
44345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44346   void * jresult ;
44347   Dali::LinearConstrainer *result = 0 ;
44348
44349   {
44350     try {
44351       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44352     } catch (std::out_of_range& e) {
44353       {
44354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44355       };
44356     } catch (std::exception& e) {
44357       {
44358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44359       };
44360     } catch (Dali::DaliException e) {
44361       {
44362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44363       };
44364     } catch (...) {
44365       {
44366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44367       };
44368     }
44369   }
44370
44371   jresult = (void *)result;
44372   return jresult;
44373 }
44374
44375
44376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44377   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44378
44379   arg1 = (Dali::LinearConstrainer *)jarg1;
44380   {
44381     try {
44382       delete arg1;
44383     } catch (std::out_of_range& e) {
44384       {
44385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44386       };
44387     } catch (std::exception& e) {
44388       {
44389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44390       };
44391     } catch (Dali::DaliException e) {
44392       {
44393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44394       };
44395     } catch (...) {
44396       {
44397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44398       };
44399     }
44400   }
44401
44402 }
44403
44404
44405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44406   void * jresult ;
44407   Dali::LinearConstrainer *arg1 = 0 ;
44408   Dali::LinearConstrainer *result = 0 ;
44409
44410   arg1 = (Dali::LinearConstrainer *)jarg1;
44411   if (!arg1) {
44412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44413     return 0;
44414   }
44415   {
44416     try {
44417       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44418     } catch (std::out_of_range& e) {
44419       {
44420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44421       };
44422     } catch (std::exception& e) {
44423       {
44424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44425       };
44426     } catch (Dali::DaliException e) {
44427       {
44428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44429       };
44430     } catch (...) {
44431       {
44432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44433       };
44434     }
44435   }
44436
44437   jresult = (void *)result;
44438   return jresult;
44439 }
44440
44441
44442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44443   void * jresult ;
44444   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44445   Dali::LinearConstrainer *arg2 = 0 ;
44446   Dali::LinearConstrainer *result = 0 ;
44447
44448   arg1 = (Dali::LinearConstrainer *)jarg1;
44449   arg2 = (Dali::LinearConstrainer *)jarg2;
44450   if (!arg2) {
44451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44452     return 0;
44453   }
44454   {
44455     try {
44456       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44457     } catch (std::out_of_range& e) {
44458       {
44459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44460       };
44461     } catch (std::exception& e) {
44462       {
44463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44464       };
44465     } catch (Dali::DaliException e) {
44466       {
44467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44468       };
44469     } catch (...) {
44470       {
44471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44472       };
44473     }
44474   }
44475
44476   jresult = (void *)result;
44477   return jresult;
44478 }
44479
44480
44481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44482   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44483   SwigValueWrapper< Dali::Property > arg2 ;
44484   SwigValueWrapper< Dali::Property > arg3 ;
44485   Dali::Vector2 *arg4 = 0 ;
44486   Dali::Vector2 *arg5 = 0 ;
44487   Dali::Property *argp2 ;
44488   Dali::Property *argp3 ;
44489
44490   arg1 = (Dali::LinearConstrainer *)jarg1;
44491   argp2 = (Dali::Property *)jarg2;
44492   if (!argp2) {
44493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44494     return ;
44495   }
44496   arg2 = *argp2;
44497   argp3 = (Dali::Property *)jarg3;
44498   if (!argp3) {
44499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44500     return ;
44501   }
44502   arg3 = *argp3;
44503   arg4 = (Dali::Vector2 *)jarg4;
44504   if (!arg4) {
44505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44506     return ;
44507   }
44508   arg5 = (Dali::Vector2 *)jarg5;
44509   if (!arg5) {
44510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44511     return ;
44512   }
44513   {
44514     try {
44515       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44516     } catch (std::out_of_range& e) {
44517       {
44518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44519       };
44520     } catch (std::exception& e) {
44521       {
44522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44523       };
44524     } catch (Dali::DaliException e) {
44525       {
44526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44527       };
44528     } catch (...) {
44529       {
44530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44531       };
44532     }
44533   }
44534
44535 }
44536
44537
44538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44539   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44540   SwigValueWrapper< Dali::Property > arg2 ;
44541   SwigValueWrapper< Dali::Property > arg3 ;
44542   Dali::Vector2 *arg4 = 0 ;
44543   Dali::Property *argp2 ;
44544   Dali::Property *argp3 ;
44545
44546   arg1 = (Dali::LinearConstrainer *)jarg1;
44547   argp2 = (Dali::Property *)jarg2;
44548   if (!argp2) {
44549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44550     return ;
44551   }
44552   arg2 = *argp2;
44553   argp3 = (Dali::Property *)jarg3;
44554   if (!argp3) {
44555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44556     return ;
44557   }
44558   arg3 = *argp3;
44559   arg4 = (Dali::Vector2 *)jarg4;
44560   if (!arg4) {
44561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44562     return ;
44563   }
44564   {
44565     try {
44566       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44567     } catch (std::out_of_range& e) {
44568       {
44569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44570       };
44571     } catch (std::exception& e) {
44572       {
44573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44574       };
44575     } catch (Dali::DaliException e) {
44576       {
44577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44578       };
44579     } catch (...) {
44580       {
44581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44582       };
44583     }
44584   }
44585
44586 }
44587
44588
44589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44590   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44591   Dali::Handle *arg2 = 0 ;
44592
44593   arg1 = (Dali::LinearConstrainer *)jarg1;
44594   arg2 = (Dali::Handle *)jarg2;
44595   if (!arg2) {
44596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44597     return ;
44598   }
44599   {
44600     try {
44601       (arg1)->Remove(*arg2);
44602     } catch (std::out_of_range& e) {
44603       {
44604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44605       };
44606     } catch (std::exception& e) {
44607       {
44608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44609       };
44610     } catch (Dali::DaliException e) {
44611       {
44612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44613       };
44614     } catch (...) {
44615       {
44616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44617       };
44618     }
44619   }
44620
44621 }
44622
44623
44624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44625   int jresult ;
44626   int result;
44627
44628   result = (int)Dali::PathConstrainer::Property::FORWARD;
44629   jresult = (int)result;
44630   return jresult;
44631 }
44632
44633
44634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44635   int jresult ;
44636   int result;
44637
44638   result = (int)Dali::PathConstrainer::Property::POINTS;
44639   jresult = (int)result;
44640   return jresult;
44641 }
44642
44643
44644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44645   int jresult ;
44646   int result;
44647
44648   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44649   jresult = (int)result;
44650   return jresult;
44651 }
44652
44653
44654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44655   void * jresult ;
44656   Dali::PathConstrainer::Property *result = 0 ;
44657
44658   {
44659     try {
44660       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44661     } catch (std::out_of_range& e) {
44662       {
44663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44664       };
44665     } catch (std::exception& e) {
44666       {
44667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44668       };
44669     } catch (Dali::DaliException e) {
44670       {
44671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44672       };
44673     } catch (...) {
44674       {
44675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44676       };
44677     }
44678   }
44679
44680   jresult = (void *)result;
44681   return jresult;
44682 }
44683
44684
44685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44686   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44687
44688   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44689   {
44690     try {
44691       delete arg1;
44692     } catch (std::out_of_range& e) {
44693       {
44694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44695       };
44696     } catch (std::exception& e) {
44697       {
44698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44699       };
44700     } catch (Dali::DaliException e) {
44701       {
44702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44703       };
44704     } catch (...) {
44705       {
44706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44707       };
44708     }
44709   }
44710
44711 }
44712
44713
44714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44715   void * jresult ;
44716   Dali::PathConstrainer result;
44717
44718   {
44719     try {
44720       result = Dali::PathConstrainer::New();
44721     } catch (std::out_of_range& e) {
44722       {
44723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44724       };
44725     } catch (std::exception& e) {
44726       {
44727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44728       };
44729     } catch (Dali::DaliException e) {
44730       {
44731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44732       };
44733     } catch (...) {
44734       {
44735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44736       };
44737     }
44738   }
44739
44740   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44741   return jresult;
44742 }
44743
44744
44745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44746   void * jresult ;
44747   Dali::BaseHandle arg1 ;
44748   Dali::BaseHandle *argp1 ;
44749   Dali::PathConstrainer result;
44750
44751   argp1 = (Dali::BaseHandle *)jarg1;
44752   if (!argp1) {
44753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44754     return 0;
44755   }
44756   arg1 = *argp1;
44757   {
44758     try {
44759       result = Dali::PathConstrainer::DownCast(arg1);
44760     } catch (std::out_of_range& e) {
44761       {
44762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44763       };
44764     } catch (std::exception& e) {
44765       {
44766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44767       };
44768     } catch (Dali::DaliException e) {
44769       {
44770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44771       };
44772     } catch (...) {
44773       {
44774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44775       };
44776     }
44777   }
44778
44779   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44780   return jresult;
44781 }
44782
44783
44784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44785   void * jresult ;
44786   Dali::PathConstrainer *result = 0 ;
44787
44788   {
44789     try {
44790       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44791     } catch (std::out_of_range& e) {
44792       {
44793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44794       };
44795     } catch (std::exception& e) {
44796       {
44797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44798       };
44799     } catch (Dali::DaliException e) {
44800       {
44801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44802       };
44803     } catch (...) {
44804       {
44805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44806       };
44807     }
44808   }
44809
44810   jresult = (void *)result;
44811   return jresult;
44812 }
44813
44814
44815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44816   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44817
44818   arg1 = (Dali::PathConstrainer *)jarg1;
44819   {
44820     try {
44821       delete arg1;
44822     } catch (std::out_of_range& e) {
44823       {
44824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44825       };
44826     } catch (std::exception& e) {
44827       {
44828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44829       };
44830     } catch (Dali::DaliException e) {
44831       {
44832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44833       };
44834     } catch (...) {
44835       {
44836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44837       };
44838     }
44839   }
44840
44841 }
44842
44843
44844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44845   void * jresult ;
44846   Dali::PathConstrainer *arg1 = 0 ;
44847   Dali::PathConstrainer *result = 0 ;
44848
44849   arg1 = (Dali::PathConstrainer *)jarg1;
44850   if (!arg1) {
44851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44852     return 0;
44853   }
44854   {
44855     try {
44856       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44857     } catch (std::out_of_range& e) {
44858       {
44859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44860       };
44861     } catch (std::exception& e) {
44862       {
44863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44864       };
44865     } catch (Dali::DaliException e) {
44866       {
44867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44868       };
44869     } catch (...) {
44870       {
44871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44872       };
44873     }
44874   }
44875
44876   jresult = (void *)result;
44877   return jresult;
44878 }
44879
44880
44881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44882   void * jresult ;
44883   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44884   Dali::PathConstrainer *arg2 = 0 ;
44885   Dali::PathConstrainer *result = 0 ;
44886
44887   arg1 = (Dali::PathConstrainer *)jarg1;
44888   arg2 = (Dali::PathConstrainer *)jarg2;
44889   if (!arg2) {
44890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44891     return 0;
44892   }
44893   {
44894     try {
44895       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44896     } catch (std::out_of_range& e) {
44897       {
44898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44899       };
44900     } catch (std::exception& e) {
44901       {
44902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44903       };
44904     } catch (Dali::DaliException e) {
44905       {
44906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44907       };
44908     } catch (...) {
44909       {
44910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44911       };
44912     }
44913   }
44914
44915   jresult = (void *)result;
44916   return jresult;
44917 }
44918
44919
44920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44921   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44922   SwigValueWrapper< Dali::Property > arg2 ;
44923   SwigValueWrapper< Dali::Property > arg3 ;
44924   Dali::Vector2 *arg4 = 0 ;
44925   Dali::Vector2 *arg5 = 0 ;
44926   Dali::Property *argp2 ;
44927   Dali::Property *argp3 ;
44928
44929   arg1 = (Dali::PathConstrainer *)jarg1;
44930   argp2 = (Dali::Property *)jarg2;
44931   if (!argp2) {
44932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44933     return ;
44934   }
44935   arg2 = *argp2;
44936   argp3 = (Dali::Property *)jarg3;
44937   if (!argp3) {
44938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44939     return ;
44940   }
44941   arg3 = *argp3;
44942   arg4 = (Dali::Vector2 *)jarg4;
44943   if (!arg4) {
44944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44945     return ;
44946   }
44947   arg5 = (Dali::Vector2 *)jarg5;
44948   if (!arg5) {
44949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44950     return ;
44951   }
44952   {
44953     try {
44954       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44955     } catch (std::out_of_range& e) {
44956       {
44957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44958       };
44959     } catch (std::exception& e) {
44960       {
44961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44962       };
44963     } catch (Dali::DaliException e) {
44964       {
44965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44966       };
44967     } catch (...) {
44968       {
44969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44970       };
44971     }
44972   }
44973
44974 }
44975
44976
44977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44978   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44979   SwigValueWrapper< Dali::Property > arg2 ;
44980   SwigValueWrapper< Dali::Property > arg3 ;
44981   Dali::Vector2 *arg4 = 0 ;
44982   Dali::Property *argp2 ;
44983   Dali::Property *argp3 ;
44984
44985   arg1 = (Dali::PathConstrainer *)jarg1;
44986   argp2 = (Dali::Property *)jarg2;
44987   if (!argp2) {
44988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44989     return ;
44990   }
44991   arg2 = *argp2;
44992   argp3 = (Dali::Property *)jarg3;
44993   if (!argp3) {
44994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44995     return ;
44996   }
44997   arg3 = *argp3;
44998   arg4 = (Dali::Vector2 *)jarg4;
44999   if (!arg4) {
45000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45001     return ;
45002   }
45003   {
45004     try {
45005       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
45006     } catch (std::out_of_range& e) {
45007       {
45008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45009       };
45010     } catch (std::exception& e) {
45011       {
45012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45013       };
45014     } catch (Dali::DaliException e) {
45015       {
45016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45017       };
45018     } catch (...) {
45019       {
45020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45021       };
45022     }
45023   }
45024
45025 }
45026
45027
45028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
45029   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45030   Dali::Handle *arg2 = 0 ;
45031
45032   arg1 = (Dali::PathConstrainer *)jarg1;
45033   arg2 = (Dali::Handle *)jarg2;
45034   if (!arg2) {
45035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
45036     return ;
45037   }
45038   {
45039     try {
45040       (arg1)->Remove(*arg2);
45041     } catch (std::out_of_range& e) {
45042       {
45043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45044       };
45045     } catch (std::exception& e) {
45046       {
45047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45048       };
45049     } catch (Dali::DaliException e) {
45050       {
45051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45052       };
45053     } catch (...) {
45054       {
45055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45056       };
45057     }
45058   }
45059
45060 }
45061
45062
45063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45064   int jresult ;
45065   Dali::FittingMode::Type result;
45066
45067   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45068   jresult = (int)result;
45069   return jresult;
45070 }
45071
45072
45073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45074   int jresult ;
45075   Dali::SamplingMode::Type result;
45076
45077   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45078   jresult = (int)result;
45079   return jresult;
45080 }
45081
45082
45083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
45084   void * jresult ;
45085   Dali::BufferImage *result = 0 ;
45086
45087   {
45088     try {
45089       result = (Dali::BufferImage *)new Dali::BufferImage();
45090     } catch (std::out_of_range& e) {
45091       {
45092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45093       };
45094     } catch (std::exception& e) {
45095       {
45096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45097       };
45098     } catch (Dali::DaliException e) {
45099       {
45100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45101       };
45102     } catch (...) {
45103       {
45104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45105       };
45106     }
45107   }
45108
45109   jresult = (void *)result;
45110   return jresult;
45111 }
45112
45113
45114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45115   void * jresult ;
45116   unsigned int arg1 ;
45117   unsigned int arg2 ;
45118   Dali::Pixel::Format arg3 ;
45119   Dali::BufferImage result;
45120
45121   arg1 = (unsigned int)jarg1;
45122   arg2 = (unsigned int)jarg2;
45123   arg3 = (Dali::Pixel::Format)jarg3;
45124   {
45125     try {
45126       result = Dali::BufferImage::New(arg1,arg2,arg3);
45127     } catch (std::out_of_range& e) {
45128       {
45129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45130       };
45131     } catch (std::exception& e) {
45132       {
45133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45134       };
45135     } catch (Dali::DaliException e) {
45136       {
45137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45138       };
45139     } catch (...) {
45140       {
45141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45142       };
45143     }
45144   }
45145
45146   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45147   return jresult;
45148 }
45149
45150
45151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45152   void * jresult ;
45153   unsigned int arg1 ;
45154   unsigned int arg2 ;
45155   Dali::BufferImage result;
45156
45157   arg1 = (unsigned int)jarg1;
45158   arg2 = (unsigned int)jarg2;
45159   {
45160     try {
45161       result = Dali::BufferImage::New(arg1,arg2);
45162     } catch (std::out_of_range& e) {
45163       {
45164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45165       };
45166     } catch (std::exception& e) {
45167       {
45168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45169       };
45170     } catch (Dali::DaliException e) {
45171       {
45172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45173       };
45174     } catch (...) {
45175       {
45176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45177       };
45178     }
45179   }
45180
45181   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45182   return jresult;
45183 }
45184
45185
45186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45187   void * jresult ;
45188   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45189   unsigned int arg2 ;
45190   unsigned int arg3 ;
45191   Dali::Pixel::Format arg4 ;
45192   unsigned int arg5 ;
45193   Dali::BufferImage result;
45194
45195   arg1 = jarg1;
45196   arg2 = (unsigned int)jarg2;
45197   arg3 = (unsigned int)jarg3;
45198   arg4 = (Dali::Pixel::Format)jarg4;
45199   arg5 = (unsigned int)jarg5;
45200   {
45201     try {
45202       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45203     } catch (std::out_of_range& e) {
45204       {
45205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45206       };
45207     } catch (std::exception& e) {
45208       {
45209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45210       };
45211     } catch (Dali::DaliException e) {
45212       {
45213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45214       };
45215     } catch (...) {
45216       {
45217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45218       };
45219     }
45220   }
45221
45222   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45223
45224
45225   return jresult;
45226 }
45227
45228
45229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45230   void * jresult ;
45231   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45232   unsigned int arg2 ;
45233   unsigned int arg3 ;
45234   Dali::Pixel::Format arg4 ;
45235   Dali::BufferImage result;
45236
45237   arg1 = jarg1;
45238   arg2 = (unsigned int)jarg2;
45239   arg3 = (unsigned int)jarg3;
45240   arg4 = (Dali::Pixel::Format)jarg4;
45241   {
45242     try {
45243       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45244     } catch (std::out_of_range& e) {
45245       {
45246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45247       };
45248     } catch (std::exception& e) {
45249       {
45250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45251       };
45252     } catch (Dali::DaliException e) {
45253       {
45254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45255       };
45256     } catch (...) {
45257       {
45258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45259       };
45260     }
45261   }
45262
45263   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45264
45265
45266   return jresult;
45267 }
45268
45269
45270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45271   void * jresult ;
45272   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45273   unsigned int arg2 ;
45274   unsigned int arg3 ;
45275   Dali::BufferImage result;
45276
45277   arg1 = jarg1;
45278   arg2 = (unsigned int)jarg2;
45279   arg3 = (unsigned int)jarg3;
45280   {
45281     try {
45282       result = Dali::BufferImage::New(arg1,arg2,arg3);
45283     } catch (std::out_of_range& e) {
45284       {
45285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45286       };
45287     } catch (std::exception& e) {
45288       {
45289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45290       };
45291     } catch (Dali::DaliException e) {
45292       {
45293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45294       };
45295     } catch (...) {
45296       {
45297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45298       };
45299     }
45300   }
45301
45302   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45303
45304
45305   return jresult;
45306 }
45307
45308
45309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45310   void * jresult ;
45311   Dali::BaseHandle arg1 ;
45312   Dali::BaseHandle *argp1 ;
45313   Dali::BufferImage result;
45314
45315   argp1 = (Dali::BaseHandle *)jarg1;
45316   if (!argp1) {
45317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45318     return 0;
45319   }
45320   arg1 = *argp1;
45321   {
45322     try {
45323       result = Dali::BufferImage::DownCast(arg1);
45324     } catch (std::out_of_range& e) {
45325       {
45326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45327       };
45328     } catch (std::exception& e) {
45329       {
45330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45331       };
45332     } catch (Dali::DaliException e) {
45333       {
45334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45335       };
45336     } catch (...) {
45337       {
45338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45339       };
45340     }
45341   }
45342
45343   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45344   return jresult;
45345 }
45346
45347
45348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45349   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45350
45351   arg1 = (Dali::BufferImage *)jarg1;
45352   {
45353     try {
45354       delete arg1;
45355     } catch (std::out_of_range& e) {
45356       {
45357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45358       };
45359     } catch (std::exception& e) {
45360       {
45361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45362       };
45363     } catch (Dali::DaliException e) {
45364       {
45365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45366       };
45367     } catch (...) {
45368       {
45369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45370       };
45371     }
45372   }
45373
45374 }
45375
45376
45377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45378   void * jresult ;
45379   Dali::BufferImage *arg1 = 0 ;
45380   Dali::BufferImage *result = 0 ;
45381
45382   arg1 = (Dali::BufferImage *)jarg1;
45383   if (!arg1) {
45384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45385     return 0;
45386   }
45387   {
45388     try {
45389       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45390     } catch (std::out_of_range& e) {
45391       {
45392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45393       };
45394     } catch (std::exception& e) {
45395       {
45396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45397       };
45398     } catch (Dali::DaliException e) {
45399       {
45400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45401       };
45402     } catch (...) {
45403       {
45404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45405       };
45406     }
45407   }
45408
45409   jresult = (void *)result;
45410   return jresult;
45411 }
45412
45413
45414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45415   void * jresult ;
45416   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45417   Dali::BufferImage *arg2 = 0 ;
45418   Dali::BufferImage *result = 0 ;
45419
45420   arg1 = (Dali::BufferImage *)jarg1;
45421   arg2 = (Dali::BufferImage *)jarg2;
45422   if (!arg2) {
45423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45424     return 0;
45425   }
45426   {
45427     try {
45428       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45429     } catch (std::out_of_range& e) {
45430       {
45431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45432       };
45433     } catch (std::exception& e) {
45434       {
45435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45436       };
45437     } catch (Dali::DaliException e) {
45438       {
45439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45440       };
45441     } catch (...) {
45442       {
45443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45444       };
45445     }
45446   }
45447
45448   jresult = (void *)result;
45449   return jresult;
45450 }
45451
45452
45453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45454   void * jresult ;
45455   Dali::BufferImage result;
45456
45457   {
45458     try {
45459       result = Dali::BufferImage::WHITE();
45460     } catch (std::out_of_range& e) {
45461       {
45462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45463       };
45464     } catch (std::exception& e) {
45465       {
45466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45467       };
45468     } catch (Dali::DaliException e) {
45469       {
45470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45471       };
45472     } catch (...) {
45473       {
45474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45475       };
45476     }
45477   }
45478
45479   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45480   return jresult;
45481 }
45482
45483
45484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45485   void * jresult ;
45486   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45487   Dali::PixelBuffer *result = 0 ;
45488
45489   arg1 = (Dali::BufferImage *)jarg1;
45490   {
45491     try {
45492       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45493     } catch (std::out_of_range& e) {
45494       {
45495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45496       };
45497     } catch (std::exception& e) {
45498       {
45499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45500       };
45501     } catch (Dali::DaliException e) {
45502       {
45503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45504       };
45505     } catch (...) {
45506       {
45507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45508       };
45509     }
45510   }
45511
45512   jresult = (void *)result;
45513   return jresult;
45514 }
45515
45516
45517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45518   unsigned int jresult ;
45519   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45520   unsigned int result;
45521
45522   arg1 = (Dali::BufferImage *)jarg1;
45523   {
45524     try {
45525       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45526     } catch (std::out_of_range& e) {
45527       {
45528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45529       };
45530     } catch (std::exception& e) {
45531       {
45532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45533       };
45534     } catch (Dali::DaliException e) {
45535       {
45536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45537       };
45538     } catch (...) {
45539       {
45540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45541       };
45542     }
45543   }
45544
45545   jresult = result;
45546   return jresult;
45547 }
45548
45549
45550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45551   unsigned int jresult ;
45552   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45553   unsigned int result;
45554
45555   arg1 = (Dali::BufferImage *)jarg1;
45556   {
45557     try {
45558       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45559     } catch (std::out_of_range& e) {
45560       {
45561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45562       };
45563     } catch (std::exception& e) {
45564       {
45565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45566       };
45567     } catch (Dali::DaliException e) {
45568       {
45569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45570       };
45571     } catch (...) {
45572       {
45573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45574       };
45575     }
45576   }
45577
45578   jresult = result;
45579   return jresult;
45580 }
45581
45582
45583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45584   int jresult ;
45585   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45586   Dali::Pixel::Format result;
45587
45588   arg1 = (Dali::BufferImage *)jarg1;
45589   {
45590     try {
45591       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45592     } catch (std::out_of_range& e) {
45593       {
45594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45595       };
45596     } catch (std::exception& e) {
45597       {
45598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45599       };
45600     } catch (Dali::DaliException e) {
45601       {
45602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45603       };
45604     } catch (...) {
45605       {
45606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45607       };
45608     }
45609   }
45610
45611   jresult = (int)result;
45612   return jresult;
45613 }
45614
45615
45616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45617   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45618
45619   arg1 = (Dali::BufferImage *)jarg1;
45620   {
45621     try {
45622       (arg1)->Update();
45623     } catch (std::out_of_range& e) {
45624       {
45625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45626       };
45627     } catch (std::exception& e) {
45628       {
45629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45630       };
45631     } catch (Dali::DaliException e) {
45632       {
45633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45634       };
45635     } catch (...) {
45636       {
45637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45638       };
45639     }
45640   }
45641
45642 }
45643
45644
45645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45646   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45647   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45648   Dali::RectArea *argp2 ;
45649
45650   arg1 = (Dali::BufferImage *)jarg1;
45651   argp2 = (Dali::RectArea *)jarg2;
45652   if (!argp2) {
45653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45654     return ;
45655   }
45656   arg2 = *argp2;
45657   {
45658     try {
45659       (arg1)->Update(arg2);
45660     } catch (std::out_of_range& e) {
45661       {
45662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45663       };
45664     } catch (std::exception& e) {
45665       {
45666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45667       };
45668     } catch (Dali::DaliException e) {
45669       {
45670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45671       };
45672     } catch (...) {
45673       {
45674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45675       };
45676     }
45677   }
45678
45679 }
45680
45681
45682 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45683   unsigned int jresult ;
45684   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45685   bool result;
45686
45687   arg1 = (Dali::BufferImage *)jarg1;
45688   {
45689     try {
45690       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45691     } catch (std::out_of_range& e) {
45692       {
45693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45694       };
45695     } catch (std::exception& e) {
45696       {
45697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45698       };
45699     } catch (Dali::DaliException e) {
45700       {
45701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45702       };
45703     } catch (...) {
45704       {
45705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45706       };
45707     }
45708   }
45709
45710   jresult = result;
45711   return jresult;
45712 }
45713
45714
45715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45716   void * jresult ;
45717   Dali::EncodedBufferImage *result = 0 ;
45718
45719   {
45720     try {
45721       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45722     } catch (std::out_of_range& e) {
45723       {
45724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45725       };
45726     } catch (std::exception& e) {
45727       {
45728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45729       };
45730     } catch (Dali::DaliException e) {
45731       {
45732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45733       };
45734     } catch (...) {
45735       {
45736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45737       };
45738     }
45739   }
45740
45741   jresult = (void *)result;
45742   return jresult;
45743 }
45744
45745
45746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45747   void * jresult ;
45748   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45749   std::size_t arg2 ;
45750   Dali::EncodedBufferImage result;
45751
45752   arg1 = (uint8_t *)jarg1;
45753   arg2 = (std::size_t)jarg2;
45754   {
45755     try {
45756       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45757     } catch (std::out_of_range& e) {
45758       {
45759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45760       };
45761     } catch (std::exception& e) {
45762       {
45763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45764       };
45765     } catch (Dali::DaliException e) {
45766       {
45767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45768       };
45769     } catch (...) {
45770       {
45771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45772       };
45773     }
45774   }
45775
45776   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45777   return jresult;
45778 }
45779
45780
45781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45782   void * jresult ;
45783   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45784   std::size_t arg2 ;
45785   Dali::ImageDimensions arg3 ;
45786   Dali::FittingMode::Type arg4 ;
45787   Dali::SamplingMode::Type arg5 ;
45788   bool arg6 ;
45789   Dali::ImageDimensions *argp3 ;
45790   Dali::EncodedBufferImage result;
45791
45792   arg1 = (uint8_t *)jarg1;
45793   arg2 = (std::size_t)jarg2;
45794   argp3 = (Dali::ImageDimensions *)jarg3;
45795   if (!argp3) {
45796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45797     return 0;
45798   }
45799   arg3 = *argp3;
45800   arg4 = (Dali::FittingMode::Type)jarg4;
45801   arg5 = (Dali::SamplingMode::Type)jarg5;
45802   arg6 = jarg6 ? true : false;
45803   {
45804     try {
45805       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45806     } catch (std::out_of_range& e) {
45807       {
45808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45809       };
45810     } catch (std::exception& e) {
45811       {
45812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45813       };
45814     } catch (Dali::DaliException e) {
45815       {
45816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45817       };
45818     } catch (...) {
45819       {
45820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45821       };
45822     }
45823   }
45824
45825   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45826   return jresult;
45827 }
45828
45829
45830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45831   void * jresult ;
45832   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45833   std::size_t arg2 ;
45834   Dali::ImageDimensions arg3 ;
45835   Dali::FittingMode::Type arg4 ;
45836   Dali::SamplingMode::Type arg5 ;
45837   Dali::ImageDimensions *argp3 ;
45838   Dali::EncodedBufferImage result;
45839
45840   arg1 = (uint8_t *)jarg1;
45841   arg2 = (std::size_t)jarg2;
45842   argp3 = (Dali::ImageDimensions *)jarg3;
45843   if (!argp3) {
45844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45845     return 0;
45846   }
45847   arg3 = *argp3;
45848   arg4 = (Dali::FittingMode::Type)jarg4;
45849   arg5 = (Dali::SamplingMode::Type)jarg5;
45850   {
45851     try {
45852       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45853     } catch (std::out_of_range& e) {
45854       {
45855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45856       };
45857     } catch (std::exception& e) {
45858       {
45859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45860       };
45861     } catch (Dali::DaliException e) {
45862       {
45863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45864       };
45865     } catch (...) {
45866       {
45867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45868       };
45869     }
45870   }
45871
45872   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45873   return jresult;
45874 }
45875
45876
45877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45878   void * jresult ;
45879   Dali::BaseHandle arg1 ;
45880   Dali::BaseHandle *argp1 ;
45881   Dali::EncodedBufferImage result;
45882
45883   argp1 = (Dali::BaseHandle *)jarg1;
45884   if (!argp1) {
45885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45886     return 0;
45887   }
45888   arg1 = *argp1;
45889   {
45890     try {
45891       result = Dali::EncodedBufferImage::DownCast(arg1);
45892     } catch (std::out_of_range& e) {
45893       {
45894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45895       };
45896     } catch (std::exception& e) {
45897       {
45898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45899       };
45900     } catch (Dali::DaliException e) {
45901       {
45902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45903       };
45904     } catch (...) {
45905       {
45906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45907       };
45908     }
45909   }
45910
45911   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45912   return jresult;
45913 }
45914
45915
45916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45917   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45918
45919   arg1 = (Dali::EncodedBufferImage *)jarg1;
45920   {
45921     try {
45922       delete arg1;
45923     } catch (std::out_of_range& e) {
45924       {
45925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45926       };
45927     } catch (std::exception& e) {
45928       {
45929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45930       };
45931     } catch (Dali::DaliException e) {
45932       {
45933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45934       };
45935     } catch (...) {
45936       {
45937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45938       };
45939     }
45940   }
45941
45942 }
45943
45944
45945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45946   void * jresult ;
45947   Dali::EncodedBufferImage *arg1 = 0 ;
45948   Dali::EncodedBufferImage *result = 0 ;
45949
45950   arg1 = (Dali::EncodedBufferImage *)jarg1;
45951   if (!arg1) {
45952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45953     return 0;
45954   }
45955   {
45956     try {
45957       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45958     } catch (std::out_of_range& e) {
45959       {
45960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45961       };
45962     } catch (std::exception& e) {
45963       {
45964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45965       };
45966     } catch (Dali::DaliException e) {
45967       {
45968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45969       };
45970     } catch (...) {
45971       {
45972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45973       };
45974     }
45975   }
45976
45977   jresult = (void *)result;
45978   return jresult;
45979 }
45980
45981
45982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45983   void * jresult ;
45984   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45985   Dali::EncodedBufferImage *arg2 = 0 ;
45986   Dali::EncodedBufferImage *result = 0 ;
45987
45988   arg1 = (Dali::EncodedBufferImage *)jarg1;
45989   arg2 = (Dali::EncodedBufferImage *)jarg2;
45990   if (!arg2) {
45991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45992     return 0;
45993   }
45994   {
45995     try {
45996       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45997     } catch (std::out_of_range& e) {
45998       {
45999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46000       };
46001     } catch (std::exception& e) {
46002       {
46003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46004       };
46005     } catch (Dali::DaliException e) {
46006       {
46007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46008       };
46009     } catch (...) {
46010       {
46011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46012       };
46013     }
46014   }
46015
46016   jresult = (void *)result;
46017   return jresult;
46018 }
46019
46020
46021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
46022   void * jresult ;
46023   Dali::NativeImage *result = 0 ;
46024
46025   {
46026     try {
46027       result = (Dali::NativeImage *)new Dali::NativeImage();
46028     } catch (std::out_of_range& e) {
46029       {
46030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46031       };
46032     } catch (std::exception& e) {
46033       {
46034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46035       };
46036     } catch (Dali::DaliException e) {
46037       {
46038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46039       };
46040     } catch (...) {
46041       {
46042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46043       };
46044     }
46045   }
46046
46047   jresult = (void *)result;
46048   return jresult;
46049 }
46050
46051
46052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
46053   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46054
46055   arg1 = (Dali::NativeImage *)jarg1;
46056   {
46057     try {
46058       delete arg1;
46059     } catch (std::out_of_range& e) {
46060       {
46061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46062       };
46063     } catch (std::exception& e) {
46064       {
46065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46066       };
46067     } catch (Dali::DaliException e) {
46068       {
46069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46070       };
46071     } catch (...) {
46072       {
46073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46074       };
46075     }
46076   }
46077
46078 }
46079
46080
46081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
46082   void * jresult ;
46083   Dali::NativeImage *arg1 = 0 ;
46084   Dali::NativeImage *result = 0 ;
46085
46086   arg1 = (Dali::NativeImage *)jarg1;
46087   if (!arg1) {
46088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46089     return 0;
46090   }
46091   {
46092     try {
46093       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46094     } catch (std::out_of_range& e) {
46095       {
46096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46097       };
46098     } catch (std::exception& e) {
46099       {
46100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46101       };
46102     } catch (Dali::DaliException e) {
46103       {
46104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46105       };
46106     } catch (...) {
46107       {
46108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46109       };
46110     }
46111   }
46112
46113   jresult = (void *)result;
46114   return jresult;
46115 }
46116
46117
46118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46119   void * jresult ;
46120   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46121   Dali::NativeImage *arg2 = 0 ;
46122   Dali::NativeImage *result = 0 ;
46123
46124   arg1 = (Dali::NativeImage *)jarg1;
46125   arg2 = (Dali::NativeImage *)jarg2;
46126   if (!arg2) {
46127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46128     return 0;
46129   }
46130   {
46131     try {
46132       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46133     } catch (std::out_of_range& e) {
46134       {
46135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46136       };
46137     } catch (std::exception& e) {
46138       {
46139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46140       };
46141     } catch (Dali::DaliException e) {
46142       {
46143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46144       };
46145     } catch (...) {
46146       {
46147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46148       };
46149     }
46150   }
46151
46152   jresult = (void *)result;
46153   return jresult;
46154 }
46155
46156
46157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46158   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46159
46160   arg1 = (Dali::NativeImage *)jarg1;
46161   {
46162     try {
46163       (arg1)->CreateGlTexture();
46164     } catch (std::out_of_range& e) {
46165       {
46166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46167       };
46168     } catch (std::exception& e) {
46169       {
46170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46171       };
46172     } catch (Dali::DaliException e) {
46173       {
46174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46175       };
46176     } catch (...) {
46177       {
46178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46179       };
46180     }
46181   }
46182
46183 }
46184
46185
46186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46187   void * jresult ;
46188   NativeImageInterface *arg1 = 0 ;
46189   Dali::NativeImage result;
46190
46191   arg1 = (NativeImageInterface *)jarg1;
46192   if (!arg1) {
46193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46194     return 0;
46195   }
46196   {
46197     try {
46198       result = Dali::NativeImage::New(*arg1);
46199     } catch (std::out_of_range& e) {
46200       {
46201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46202       };
46203     } catch (std::exception& e) {
46204       {
46205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46206       };
46207     } catch (Dali::DaliException e) {
46208       {
46209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46210       };
46211     } catch (...) {
46212       {
46213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46214       };
46215     }
46216   }
46217
46218   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46219   return jresult;
46220 }
46221
46222
46223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46224   void * jresult ;
46225   Dali::BaseHandle arg1 ;
46226   Dali::BaseHandle *argp1 ;
46227   Dali::NativeImage result;
46228
46229   argp1 = (Dali::BaseHandle *)jarg1;
46230   if (!argp1) {
46231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46232     return 0;
46233   }
46234   arg1 = *argp1;
46235   {
46236     try {
46237       result = Dali::NativeImage::DownCast(arg1);
46238     } catch (std::out_of_range& e) {
46239       {
46240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46241       };
46242     } catch (std::exception& e) {
46243       {
46244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46245       };
46246     } catch (Dali::DaliException e) {
46247       {
46248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46249       };
46250     } catch (...) {
46251       {
46252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46253       };
46254     }
46255   }
46256
46257   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46258   return jresult;
46259 }
46260
46261
46262 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46263   char * jresult ;
46264   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46265   char *result = 0 ;
46266
46267   arg1 = (Dali::NativeImage *)jarg1;
46268   {
46269     try {
46270       result = (char *)(arg1)->GetCustomFragmentPreFix();
46271     } catch (std::out_of_range& e) {
46272       {
46273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46274       };
46275     } catch (std::exception& e) {
46276       {
46277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46278       };
46279     } catch (Dali::DaliException e) {
46280       {
46281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46282       };
46283     } catch (...) {
46284       {
46285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46286       };
46287     }
46288   }
46289
46290   jresult = SWIG_csharp_string_callback((const char *)result);
46291   return jresult;
46292 }
46293
46294
46295 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46296   char * jresult ;
46297   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46298   char *result = 0 ;
46299
46300   arg1 = (Dali::NativeImage *)jarg1;
46301   {
46302     try {
46303       result = (char *)(arg1)->GetCustomSamplerTypename();
46304     } catch (std::out_of_range& e) {
46305       {
46306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46307       };
46308     } catch (std::exception& e) {
46309       {
46310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46311       };
46312     } catch (Dali::DaliException e) {
46313       {
46314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46315       };
46316     } catch (...) {
46317       {
46318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46319       };
46320     }
46321   }
46322
46323   jresult = SWIG_csharp_string_callback((const char *)result);
46324   return jresult;
46325 }
46326
46327
46328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46329   unsigned int jresult ;
46330   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46331   bool result;
46332
46333   arg1 = (Dali::NativeImageInterface *)jarg1;
46334   {
46335     try {
46336       result = (bool)(arg1)->GlExtensionCreate();
46337     } catch (std::out_of_range& e) {
46338       {
46339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46340       };
46341     } catch (std::exception& e) {
46342       {
46343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46344       };
46345     } catch (Dali::DaliException e) {
46346       {
46347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46348       };
46349     } catch (...) {
46350       {
46351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46352       };
46353     }
46354   }
46355
46356   jresult = result;
46357   return jresult;
46358 }
46359
46360
46361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46362   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46363
46364   arg1 = (Dali::NativeImageInterface *)jarg1;
46365   {
46366     try {
46367       (arg1)->GlExtensionDestroy();
46368     } catch (std::out_of_range& e) {
46369       {
46370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46371       };
46372     } catch (std::exception& e) {
46373       {
46374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46375       };
46376     } catch (Dali::DaliException e) {
46377       {
46378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46379       };
46380     } catch (...) {
46381       {
46382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46383       };
46384     }
46385   }
46386
46387 }
46388
46389
46390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46391   unsigned int jresult ;
46392   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46393   unsigned int result;
46394
46395   arg1 = (Dali::NativeImageInterface *)jarg1;
46396   {
46397     try {
46398       result = (unsigned int)(arg1)->TargetTexture();
46399     } catch (std::out_of_range& e) {
46400       {
46401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46402       };
46403     } catch (std::exception& e) {
46404       {
46405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46406       };
46407     } catch (Dali::DaliException e) {
46408       {
46409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46410       };
46411     } catch (...) {
46412       {
46413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46414       };
46415     }
46416   }
46417
46418   jresult = result;
46419   return jresult;
46420 }
46421
46422
46423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46424   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46425
46426   arg1 = (Dali::NativeImageInterface *)jarg1;
46427   {
46428     try {
46429       (arg1)->PrepareTexture();
46430     } catch (std::out_of_range& e) {
46431       {
46432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46433       };
46434     } catch (std::exception& e) {
46435       {
46436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46437       };
46438     } catch (Dali::DaliException e) {
46439       {
46440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46441       };
46442     } catch (...) {
46443       {
46444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46445       };
46446     }
46447   }
46448
46449 }
46450
46451
46452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46453   unsigned int jresult ;
46454   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46455   unsigned int result;
46456
46457   arg1 = (Dali::NativeImageInterface *)jarg1;
46458   {
46459     try {
46460       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46461     } catch (std::out_of_range& e) {
46462       {
46463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46464       };
46465     } catch (std::exception& e) {
46466       {
46467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46468       };
46469     } catch (Dali::DaliException e) {
46470       {
46471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46472       };
46473     } catch (...) {
46474       {
46475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46476       };
46477     }
46478   }
46479
46480   jresult = result;
46481   return jresult;
46482 }
46483
46484
46485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46486   unsigned int jresult ;
46487   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46488   unsigned int result;
46489
46490   arg1 = (Dali::NativeImageInterface *)jarg1;
46491   {
46492     try {
46493       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46494     } catch (std::out_of_range& e) {
46495       {
46496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46497       };
46498     } catch (std::exception& e) {
46499       {
46500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46501       };
46502     } catch (Dali::DaliException e) {
46503       {
46504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46505       };
46506     } catch (...) {
46507       {
46508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46509       };
46510     }
46511   }
46512
46513   jresult = result;
46514   return jresult;
46515 }
46516
46517
46518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46519   unsigned int jresult ;
46520   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46521   bool result;
46522
46523   arg1 = (Dali::NativeImageInterface *)jarg1;
46524   {
46525     try {
46526       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46527     } catch (std::out_of_range& e) {
46528       {
46529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46530       };
46531     } catch (std::exception& e) {
46532       {
46533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46534       };
46535     } catch (Dali::DaliException e) {
46536       {
46537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46538       };
46539     } catch (...) {
46540       {
46541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46542       };
46543     }
46544   }
46545
46546   jresult = result;
46547   return jresult;
46548 }
46549
46550
46551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46552   void * jresult ;
46553   std::string *arg1 = 0 ;
46554   Dali::ImageDimensions result;
46555
46556   if (!jarg1) {
46557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46558     return 0;
46559   }
46560   std::string arg1_str(jarg1);
46561   arg1 = &arg1_str;
46562   {
46563     try {
46564       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46565     } catch (std::out_of_range& e) {
46566       {
46567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46568       };
46569     } catch (std::exception& e) {
46570       {
46571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46572       };
46573     } catch (Dali::DaliException e) {
46574       {
46575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46576       };
46577     } catch (...) {
46578       {
46579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46580       };
46581     }
46582   }
46583
46584   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46585
46586   //argout typemap for const std::string&
46587
46588   return jresult;
46589 }
46590
46591
46592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46593   void * jresult ;
46594   Dali::ResourceImage *result = 0 ;
46595
46596   {
46597     try {
46598       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46599     } catch (std::out_of_range& e) {
46600       {
46601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46602       };
46603     } catch (std::exception& e) {
46604       {
46605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46606       };
46607     } catch (Dali::DaliException e) {
46608       {
46609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46610       };
46611     } catch (...) {
46612       {
46613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46614       };
46615     }
46616   }
46617
46618   jresult = (void *)result;
46619   return jresult;
46620 }
46621
46622
46623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46624   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46625
46626   arg1 = (Dali::ResourceImage *)jarg1;
46627   {
46628     try {
46629       delete arg1;
46630     } catch (std::out_of_range& e) {
46631       {
46632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46633       };
46634     } catch (std::exception& e) {
46635       {
46636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46637       };
46638     } catch (Dali::DaliException e) {
46639       {
46640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46641       };
46642     } catch (...) {
46643       {
46644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46645       };
46646     }
46647   }
46648
46649 }
46650
46651
46652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46653   void * jresult ;
46654   Dali::ResourceImage *arg1 = 0 ;
46655   Dali::ResourceImage *result = 0 ;
46656
46657   arg1 = (Dali::ResourceImage *)jarg1;
46658   if (!arg1) {
46659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46660     return 0;
46661   }
46662   {
46663     try {
46664       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46665     } catch (std::out_of_range& e) {
46666       {
46667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46668       };
46669     } catch (std::exception& e) {
46670       {
46671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46672       };
46673     } catch (Dali::DaliException e) {
46674       {
46675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46676       };
46677     } catch (...) {
46678       {
46679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46680       };
46681     }
46682   }
46683
46684   jresult = (void *)result;
46685   return jresult;
46686 }
46687
46688
46689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46690   void * jresult ;
46691   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46692   Dali::ResourceImage *arg2 = 0 ;
46693   Dali::ResourceImage *result = 0 ;
46694
46695   arg1 = (Dali::ResourceImage *)jarg1;
46696   arg2 = (Dali::ResourceImage *)jarg2;
46697   if (!arg2) {
46698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46699     return 0;
46700   }
46701   {
46702     try {
46703       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46704     } catch (std::out_of_range& e) {
46705       {
46706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46707       };
46708     } catch (std::exception& e) {
46709       {
46710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46711       };
46712     } catch (Dali::DaliException e) {
46713       {
46714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46715       };
46716     } catch (...) {
46717       {
46718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46719       };
46720     }
46721   }
46722
46723   jresult = (void *)result;
46724   return jresult;
46725 }
46726
46727
46728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46729   void * jresult ;
46730   std::string *arg1 = 0 ;
46731   bool arg2 ;
46732   Dali::ResourceImage result;
46733
46734   if (!jarg1) {
46735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46736     return 0;
46737   }
46738   std::string arg1_str(jarg1);
46739   arg1 = &arg1_str;
46740   arg2 = jarg2 ? true : false;
46741   {
46742     try {
46743       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46744     } catch (std::out_of_range& e) {
46745       {
46746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46747       };
46748     } catch (std::exception& e) {
46749       {
46750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46751       };
46752     } catch (Dali::DaliException e) {
46753       {
46754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46755       };
46756     } catch (...) {
46757       {
46758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46759       };
46760     }
46761   }
46762
46763   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46764
46765   //argout typemap for const std::string&
46766
46767   return jresult;
46768 }
46769
46770
46771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46772   void * jresult ;
46773   std::string *arg1 = 0 ;
46774   Dali::ResourceImage result;
46775
46776   if (!jarg1) {
46777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46778     return 0;
46779   }
46780   std::string arg1_str(jarg1);
46781   arg1 = &arg1_str;
46782   {
46783     try {
46784       result = Dali::ResourceImage::New((std::string const &)*arg1);
46785     } catch (std::out_of_range& e) {
46786       {
46787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46788       };
46789     } catch (std::exception& e) {
46790       {
46791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46792       };
46793     } catch (Dali::DaliException e) {
46794       {
46795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46796       };
46797     } catch (...) {
46798       {
46799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46800       };
46801     }
46802   }
46803
46804   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46805
46806   //argout typemap for const std::string&
46807
46808   return jresult;
46809 }
46810
46811
46812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46813   void * jresult ;
46814   std::string *arg1 = 0 ;
46815   Dali::ImageDimensions arg2 ;
46816   Dali::FittingMode::Type arg3 ;
46817   Dali::SamplingMode::Type arg4 ;
46818   bool arg5 ;
46819   Dali::ImageDimensions *argp2 ;
46820   Dali::ResourceImage result;
46821
46822   if (!jarg1) {
46823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46824     return 0;
46825   }
46826   std::string arg1_str(jarg1);
46827   arg1 = &arg1_str;
46828   argp2 = (Dali::ImageDimensions *)jarg2;
46829   if (!argp2) {
46830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46831     return 0;
46832   }
46833   arg2 = *argp2;
46834   arg3 = (Dali::FittingMode::Type)jarg3;
46835   arg4 = (Dali::SamplingMode::Type)jarg4;
46836   arg5 = jarg5 ? true : false;
46837   {
46838     try {
46839       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46840     } catch (std::out_of_range& e) {
46841       {
46842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46843       };
46844     } catch (std::exception& e) {
46845       {
46846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46847       };
46848     } catch (Dali::DaliException e) {
46849       {
46850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46851       };
46852     } catch (...) {
46853       {
46854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46855       };
46856     }
46857   }
46858
46859   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46860
46861   //argout typemap for const std::string&
46862
46863   return jresult;
46864 }
46865
46866
46867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46868   void * jresult ;
46869   std::string *arg1 = 0 ;
46870   Dali::ImageDimensions arg2 ;
46871   Dali::FittingMode::Type arg3 ;
46872   Dali::SamplingMode::Type arg4 ;
46873   Dali::ImageDimensions *argp2 ;
46874   Dali::ResourceImage result;
46875
46876   if (!jarg1) {
46877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46878     return 0;
46879   }
46880   std::string arg1_str(jarg1);
46881   arg1 = &arg1_str;
46882   argp2 = (Dali::ImageDimensions *)jarg2;
46883   if (!argp2) {
46884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46885     return 0;
46886   }
46887   arg2 = *argp2;
46888   arg3 = (Dali::FittingMode::Type)jarg3;
46889   arg4 = (Dali::SamplingMode::Type)jarg4;
46890   {
46891     try {
46892       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46893     } catch (std::out_of_range& e) {
46894       {
46895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46896       };
46897     } catch (std::exception& e) {
46898       {
46899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46900       };
46901     } catch (Dali::DaliException e) {
46902       {
46903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46904       };
46905     } catch (...) {
46906       {
46907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46908       };
46909     }
46910   }
46911
46912   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46913
46914   //argout typemap for const std::string&
46915
46916   return jresult;
46917 }
46918
46919
46920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46921   void * jresult ;
46922   std::string *arg1 = 0 ;
46923   Dali::ImageDimensions arg2 ;
46924   Dali::FittingMode::Type arg3 ;
46925   Dali::ImageDimensions *argp2 ;
46926   Dali::ResourceImage result;
46927
46928   if (!jarg1) {
46929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46930     return 0;
46931   }
46932   std::string arg1_str(jarg1);
46933   arg1 = &arg1_str;
46934   argp2 = (Dali::ImageDimensions *)jarg2;
46935   if (!argp2) {
46936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46937     return 0;
46938   }
46939   arg2 = *argp2;
46940   arg3 = (Dali::FittingMode::Type)jarg3;
46941   {
46942     try {
46943       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46944     } catch (std::out_of_range& e) {
46945       {
46946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46947       };
46948     } catch (std::exception& e) {
46949       {
46950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46951       };
46952     } catch (Dali::DaliException e) {
46953       {
46954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46955       };
46956     } catch (...) {
46957       {
46958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46959       };
46960     }
46961   }
46962
46963   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46964
46965   //argout typemap for const std::string&
46966
46967   return jresult;
46968 }
46969
46970
46971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46972   void * jresult ;
46973   std::string *arg1 = 0 ;
46974   Dali::ImageDimensions arg2 ;
46975   Dali::ImageDimensions *argp2 ;
46976   Dali::ResourceImage result;
46977
46978   if (!jarg1) {
46979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46980     return 0;
46981   }
46982   std::string arg1_str(jarg1);
46983   arg1 = &arg1_str;
46984   argp2 = (Dali::ImageDimensions *)jarg2;
46985   if (!argp2) {
46986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46987     return 0;
46988   }
46989   arg2 = *argp2;
46990   {
46991     try {
46992       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46993     } catch (std::out_of_range& e) {
46994       {
46995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46996       };
46997     } catch (std::exception& e) {
46998       {
46999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47000       };
47001     } catch (Dali::DaliException e) {
47002       {
47003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47004       };
47005     } catch (...) {
47006       {
47007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47008       };
47009     }
47010   }
47011
47012   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47013
47014   //argout typemap for const std::string&
47015
47016   return jresult;
47017 }
47018
47019
47020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
47021   void * jresult ;
47022   Dali::BaseHandle arg1 ;
47023   Dali::BaseHandle *argp1 ;
47024   Dali::ResourceImage result;
47025
47026   argp1 = (Dali::BaseHandle *)jarg1;
47027   if (!argp1) {
47028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47029     return 0;
47030   }
47031   arg1 = *argp1;
47032   {
47033     try {
47034       result = Dali::ResourceImage::DownCast(arg1);
47035     } catch (std::out_of_range& e) {
47036       {
47037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47038       };
47039     } catch (std::exception& e) {
47040       {
47041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47042       };
47043     } catch (Dali::DaliException e) {
47044       {
47045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47046       };
47047     } catch (...) {
47048       {
47049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47050       };
47051     }
47052   }
47053
47054   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47055   return jresult;
47056 }
47057
47058
47059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
47060   int jresult ;
47061   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47062   Dali::LoadingState result;
47063
47064   arg1 = (Dali::ResourceImage *)jarg1;
47065   {
47066     try {
47067       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
47068     } catch (std::out_of_range& e) {
47069       {
47070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47071       };
47072     } catch (std::exception& e) {
47073       {
47074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47075       };
47076     } catch (Dali::DaliException e) {
47077       {
47078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47079       };
47080     } catch (...) {
47081       {
47082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47083       };
47084     }
47085   }
47086
47087   jresult = (int)result;
47088   return jresult;
47089 }
47090
47091
47092 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47093   char * jresult ;
47094   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47095   std::string result;
47096
47097   arg1 = (Dali::ResourceImage *)jarg1;
47098   {
47099     try {
47100       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47101     } catch (std::out_of_range& e) {
47102       {
47103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47104       };
47105     } catch (std::exception& e) {
47106       {
47107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47108       };
47109     } catch (Dali::DaliException e) {
47110       {
47111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47112       };
47113     } catch (...) {
47114       {
47115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47116       };
47117     }
47118   }
47119
47120   jresult = SWIG_csharp_string_callback((&result)->c_str());
47121   return jresult;
47122 }
47123
47124
47125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47126   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47127
47128   arg1 = (Dali::ResourceImage *)jarg1;
47129   {
47130     try {
47131       (arg1)->Reload();
47132     } catch (std::out_of_range& e) {
47133       {
47134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47135       };
47136     } catch (std::exception& e) {
47137       {
47138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47139       };
47140     } catch (Dali::DaliException e) {
47141       {
47142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47143       };
47144     } catch (...) {
47145       {
47146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47147       };
47148     }
47149   }
47150
47151 }
47152
47153
47154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47155   void * jresult ;
47156   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47157   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47158
47159   arg1 = (Dali::ResourceImage *)jarg1;
47160   {
47161     try {
47162       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47163     } catch (std::out_of_range& e) {
47164       {
47165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47166       };
47167     } catch (std::exception& e) {
47168       {
47169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47170       };
47171     } catch (Dali::DaliException e) {
47172       {
47173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47174       };
47175     } catch (...) {
47176       {
47177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47178       };
47179     }
47180   }
47181
47182   jresult = (void *)result;
47183   return jresult;
47184 }
47185
47186
47187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47188   void * jresult ;
47189   Dali::FrameBufferImage *result = 0 ;
47190
47191   {
47192     try {
47193       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47194     } catch (std::out_of_range& e) {
47195       {
47196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47197       };
47198     } catch (std::exception& e) {
47199       {
47200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47201       };
47202     } catch (Dali::DaliException e) {
47203       {
47204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47205       };
47206     } catch (...) {
47207       {
47208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47209       };
47210     }
47211   }
47212
47213   jresult = (void *)result;
47214   return jresult;
47215 }
47216
47217
47218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47219   void * jresult ;
47220   unsigned int arg1 ;
47221   unsigned int arg2 ;
47222   Dali::Pixel::Format arg3 ;
47223   Dali::RenderBuffer::Format arg4 ;
47224   Dali::FrameBufferImage result;
47225
47226   arg1 = (unsigned int)jarg1;
47227   arg2 = (unsigned int)jarg2;
47228   arg3 = (Dali::Pixel::Format)jarg3;
47229   arg4 = (Dali::RenderBuffer::Format)jarg4;
47230   {
47231     try {
47232       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47233     } catch (std::out_of_range& e) {
47234       {
47235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47236       };
47237     } catch (std::exception& e) {
47238       {
47239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47240       };
47241     } catch (Dali::DaliException e) {
47242       {
47243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47244       };
47245     } catch (...) {
47246       {
47247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47248       };
47249     }
47250   }
47251
47252   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47253   return jresult;
47254 }
47255
47256
47257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47258   void * jresult ;
47259   unsigned int arg1 ;
47260   unsigned int arg2 ;
47261   Dali::Pixel::Format arg3 ;
47262   Dali::FrameBufferImage result;
47263
47264   arg1 = (unsigned int)jarg1;
47265   arg2 = (unsigned int)jarg2;
47266   arg3 = (Dali::Pixel::Format)jarg3;
47267   {
47268     try {
47269       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47270     } catch (std::out_of_range& e) {
47271       {
47272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47273       };
47274     } catch (std::exception& e) {
47275       {
47276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47277       };
47278     } catch (Dali::DaliException e) {
47279       {
47280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47281       };
47282     } catch (...) {
47283       {
47284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47285       };
47286     }
47287   }
47288
47289   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47290   return jresult;
47291 }
47292
47293
47294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47295   void * jresult ;
47296   unsigned int arg1 ;
47297   unsigned int arg2 ;
47298   Dali::FrameBufferImage result;
47299
47300   arg1 = (unsigned int)jarg1;
47301   arg2 = (unsigned int)jarg2;
47302   {
47303     try {
47304       result = Dali::FrameBufferImage::New(arg1,arg2);
47305     } catch (std::out_of_range& e) {
47306       {
47307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47308       };
47309     } catch (std::exception& e) {
47310       {
47311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47312       };
47313     } catch (Dali::DaliException e) {
47314       {
47315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47316       };
47317     } catch (...) {
47318       {
47319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47320       };
47321     }
47322   }
47323
47324   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47325   return jresult;
47326 }
47327
47328
47329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47330   void * jresult ;
47331   unsigned int arg1 ;
47332   Dali::FrameBufferImage result;
47333
47334   arg1 = (unsigned int)jarg1;
47335   {
47336     try {
47337       result = Dali::FrameBufferImage::New(arg1);
47338     } catch (std::out_of_range& e) {
47339       {
47340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47341       };
47342     } catch (std::exception& e) {
47343       {
47344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47345       };
47346     } catch (Dali::DaliException e) {
47347       {
47348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47349       };
47350     } catch (...) {
47351       {
47352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47353       };
47354     }
47355   }
47356
47357   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47358   return jresult;
47359 }
47360
47361
47362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47363   void * jresult ;
47364   Dali::FrameBufferImage result;
47365
47366   {
47367     try {
47368       result = Dali::FrameBufferImage::New();
47369     } catch (std::out_of_range& e) {
47370       {
47371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47372       };
47373     } catch (std::exception& e) {
47374       {
47375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47376       };
47377     } catch (Dali::DaliException e) {
47378       {
47379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47380       };
47381     } catch (...) {
47382       {
47383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47384       };
47385     }
47386   }
47387
47388   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47389   return jresult;
47390 }
47391
47392
47393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47394   void * jresult ;
47395   Dali::NativeImageInterface *arg1 = 0 ;
47396   Dali::FrameBufferImage result;
47397
47398   arg1 = (Dali::NativeImageInterface *)jarg1;
47399   if (!arg1) {
47400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47401     return 0;
47402   }
47403   {
47404     try {
47405       result = Dali::FrameBufferImage::New(*arg1);
47406     } catch (std::out_of_range& e) {
47407       {
47408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47409       };
47410     } catch (std::exception& e) {
47411       {
47412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47413       };
47414     } catch (Dali::DaliException e) {
47415       {
47416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47417       };
47418     } catch (...) {
47419       {
47420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47421       };
47422     }
47423   }
47424
47425   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47426   return jresult;
47427 }
47428
47429
47430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47431   void * jresult ;
47432   Dali::BaseHandle arg1 ;
47433   Dali::BaseHandle *argp1 ;
47434   Dali::FrameBufferImage result;
47435
47436   argp1 = (Dali::BaseHandle *)jarg1;
47437   if (!argp1) {
47438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47439     return 0;
47440   }
47441   arg1 = *argp1;
47442   {
47443     try {
47444       result = Dali::FrameBufferImage::DownCast(arg1);
47445     } catch (std::out_of_range& e) {
47446       {
47447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47448       };
47449     } catch (std::exception& e) {
47450       {
47451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47452       };
47453     } catch (Dali::DaliException e) {
47454       {
47455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47456       };
47457     } catch (...) {
47458       {
47459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47460       };
47461     }
47462   }
47463
47464   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47465   return jresult;
47466 }
47467
47468
47469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47470   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47471
47472   arg1 = (Dali::FrameBufferImage *)jarg1;
47473   {
47474     try {
47475       delete arg1;
47476     } catch (std::out_of_range& e) {
47477       {
47478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47479       };
47480     } catch (std::exception& e) {
47481       {
47482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47483       };
47484     } catch (Dali::DaliException e) {
47485       {
47486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47487       };
47488     } catch (...) {
47489       {
47490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47491       };
47492     }
47493   }
47494
47495 }
47496
47497
47498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47499   void * jresult ;
47500   Dali::FrameBufferImage *arg1 = 0 ;
47501   Dali::FrameBufferImage *result = 0 ;
47502
47503   arg1 = (Dali::FrameBufferImage *)jarg1;
47504   if (!arg1) {
47505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47506     return 0;
47507   }
47508   {
47509     try {
47510       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47511     } catch (std::out_of_range& e) {
47512       {
47513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47514       };
47515     } catch (std::exception& e) {
47516       {
47517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47518       };
47519     } catch (Dali::DaliException e) {
47520       {
47521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47522       };
47523     } catch (...) {
47524       {
47525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47526       };
47527     }
47528   }
47529
47530   jresult = (void *)result;
47531   return jresult;
47532 }
47533
47534
47535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47536   void * jresult ;
47537   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47538   Dali::FrameBufferImage *arg2 = 0 ;
47539   Dali::FrameBufferImage *result = 0 ;
47540
47541   arg1 = (Dali::FrameBufferImage *)jarg1;
47542   arg2 = (Dali::FrameBufferImage *)jarg2;
47543   if (!arg2) {
47544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47545     return 0;
47546   }
47547   {
47548     try {
47549       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47550     } catch (std::out_of_range& e) {
47551       {
47552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47553       };
47554     } catch (std::exception& e) {
47555       {
47556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47557       };
47558     } catch (Dali::DaliException e) {
47559       {
47560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47561       };
47562     } catch (...) {
47563       {
47564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47565       };
47566     }
47567   }
47568
47569   jresult = (void *)result;
47570   return jresult;
47571 }
47572
47573
47574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47575   void * jresult ;
47576   Dali::NinePatchImage *result = 0 ;
47577
47578   {
47579     try {
47580       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47581     } catch (std::out_of_range& e) {
47582       {
47583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47584       };
47585     } catch (std::exception& e) {
47586       {
47587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47588       };
47589     } catch (Dali::DaliException e) {
47590       {
47591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47592       };
47593     } catch (...) {
47594       {
47595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47596       };
47597     }
47598   }
47599
47600   jresult = (void *)result;
47601   return jresult;
47602 }
47603
47604
47605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47606   void * jresult ;
47607   std::string *arg1 = 0 ;
47608   Dali::NinePatchImage result;
47609
47610   if (!jarg1) {
47611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47612     return 0;
47613   }
47614   std::string arg1_str(jarg1);
47615   arg1 = &arg1_str;
47616   {
47617     try {
47618       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47619     } catch (std::out_of_range& e) {
47620       {
47621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47622       };
47623     } catch (std::exception& e) {
47624       {
47625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47626       };
47627     } catch (Dali::DaliException e) {
47628       {
47629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47630       };
47631     } catch (...) {
47632       {
47633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47634       };
47635     }
47636   }
47637
47638   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47639
47640   //argout typemap for const std::string&
47641
47642   return jresult;
47643 }
47644
47645
47646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47647   void * jresult ;
47648   Dali::BaseHandle arg1 ;
47649   Dali::BaseHandle *argp1 ;
47650   Dali::NinePatchImage result;
47651
47652   argp1 = (Dali::BaseHandle *)jarg1;
47653   if (!argp1) {
47654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47655     return 0;
47656   }
47657   arg1 = *argp1;
47658   {
47659     try {
47660       result = Dali::NinePatchImage::DownCast(arg1);
47661     } catch (std::out_of_range& e) {
47662       {
47663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47664       };
47665     } catch (std::exception& e) {
47666       {
47667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47668       };
47669     } catch (Dali::DaliException e) {
47670       {
47671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47672       };
47673     } catch (...) {
47674       {
47675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47676       };
47677     }
47678   }
47679
47680   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47681   return jresult;
47682 }
47683
47684
47685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47686   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47687
47688   arg1 = (Dali::NinePatchImage *)jarg1;
47689   {
47690     try {
47691       delete arg1;
47692     } catch (std::out_of_range& e) {
47693       {
47694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47695       };
47696     } catch (std::exception& e) {
47697       {
47698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47699       };
47700     } catch (Dali::DaliException e) {
47701       {
47702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47703       };
47704     } catch (...) {
47705       {
47706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47707       };
47708     }
47709   }
47710
47711 }
47712
47713
47714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47715   void * jresult ;
47716   Dali::NinePatchImage *arg1 = 0 ;
47717   Dali::NinePatchImage *result = 0 ;
47718
47719   arg1 = (Dali::NinePatchImage *)jarg1;
47720   if (!arg1) {
47721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47722     return 0;
47723   }
47724   {
47725     try {
47726       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47727     } catch (std::out_of_range& e) {
47728       {
47729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47730       };
47731     } catch (std::exception& e) {
47732       {
47733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47734       };
47735     } catch (Dali::DaliException e) {
47736       {
47737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47738       };
47739     } catch (...) {
47740       {
47741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47742       };
47743     }
47744   }
47745
47746   jresult = (void *)result;
47747   return jresult;
47748 }
47749
47750
47751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47752   void * jresult ;
47753   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47754   Dali::NinePatchImage *arg2 = 0 ;
47755   Dali::NinePatchImage *result = 0 ;
47756
47757   arg1 = (Dali::NinePatchImage *)jarg1;
47758   arg2 = (Dali::NinePatchImage *)jarg2;
47759   if (!arg2) {
47760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47761     return 0;
47762   }
47763   {
47764     try {
47765       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47766     } catch (std::out_of_range& e) {
47767       {
47768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47769       };
47770     } catch (std::exception& e) {
47771       {
47772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47773       };
47774     } catch (Dali::DaliException e) {
47775       {
47776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47777       };
47778     } catch (...) {
47779       {
47780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47781       };
47782     }
47783   }
47784
47785   jresult = (void *)result;
47786   return jresult;
47787 }
47788
47789
47790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47791   void * jresult ;
47792   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47793   Dali::Vector4 result;
47794
47795   arg1 = (Dali::NinePatchImage *)jarg1;
47796   {
47797     try {
47798       result = (arg1)->GetStretchBorders();
47799     } catch (std::out_of_range& e) {
47800       {
47801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47802       };
47803     } catch (std::exception& e) {
47804       {
47805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47806       };
47807     } catch (Dali::DaliException e) {
47808       {
47809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47810       };
47811     } catch (...) {
47812       {
47813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47814       };
47815     }
47816   }
47817
47818   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47819   return jresult;
47820 }
47821
47822
47823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47824   void * jresult ;
47825   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47826   Dali::NinePatchImage::StretchRanges *result = 0 ;
47827
47828   arg1 = (Dali::NinePatchImage *)jarg1;
47829   {
47830     try {
47831       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47832     } catch (std::out_of_range& e) {
47833       {
47834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47835       };
47836     } catch (std::exception& e) {
47837       {
47838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47839       };
47840     } catch (Dali::DaliException e) {
47841       {
47842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47843       };
47844     } catch (...) {
47845       {
47846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47847       };
47848     }
47849   }
47850
47851   jresult = (void *)result;
47852   return jresult;
47853 }
47854
47855
47856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47857   void * jresult ;
47858   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47859   Dali::NinePatchImage::StretchRanges *result = 0 ;
47860
47861   arg1 = (Dali::NinePatchImage *)jarg1;
47862   {
47863     try {
47864       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47865     } catch (std::out_of_range& e) {
47866       {
47867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47868       };
47869     } catch (std::exception& e) {
47870       {
47871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47872       };
47873     } catch (Dali::DaliException e) {
47874       {
47875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47876       };
47877     } catch (...) {
47878       {
47879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47880       };
47881     }
47882   }
47883
47884   jresult = (void *)result;
47885   return jresult;
47886 }
47887
47888
47889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47890   void * jresult ;
47891   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47892   Dali::Rect< int > result;
47893
47894   arg1 = (Dali::NinePatchImage *)jarg1;
47895   {
47896     try {
47897       result = (arg1)->GetChildRectangle();
47898     } catch (std::out_of_range& e) {
47899       {
47900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47901       };
47902     } catch (std::exception& e) {
47903       {
47904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47905       };
47906     } catch (Dali::DaliException e) {
47907       {
47908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47909       };
47910     } catch (...) {
47911       {
47912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47913       };
47914     }
47915   }
47916
47917   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47918   return jresult;
47919 }
47920
47921
47922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47923   void * jresult ;
47924   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47925   Dali::BufferImage result;
47926
47927   arg1 = (Dali::NinePatchImage *)jarg1;
47928   {
47929     try {
47930       result = (arg1)->CreateCroppedBufferImage();
47931     } catch (std::out_of_range& e) {
47932       {
47933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47934       };
47935     } catch (std::exception& e) {
47936       {
47937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47938       };
47939     } catch (Dali::DaliException e) {
47940       {
47941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47942       };
47943     } catch (...) {
47944       {
47945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47946       };
47947     }
47948   }
47949
47950   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47951   return jresult;
47952 }
47953
47954
47955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47956   unsigned int jresult ;
47957   std::string *arg1 = 0 ;
47958   bool result;
47959
47960   if (!jarg1) {
47961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47962     return 0;
47963   }
47964   std::string arg1_str(jarg1);
47965   arg1 = &arg1_str;
47966   {
47967     try {
47968       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47969     } catch (std::out_of_range& e) {
47970       {
47971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47972       };
47973     } catch (std::exception& e) {
47974       {
47975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47976       };
47977     } catch (Dali::DaliException e) {
47978       {
47979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47980       };
47981     } catch (...) {
47982       {
47983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47984       };
47985     }
47986   }
47987
47988   jresult = result;
47989
47990   //argout typemap for const std::string&
47991
47992   return jresult;
47993 }
47994
47995
47996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47997   int jresult ;
47998   int result;
47999
48000   result = (int)Dali::CameraActor::Property::TYPE;
48001   jresult = (int)result;
48002   return jresult;
48003 }
48004
48005
48006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
48007   int jresult ;
48008   int result;
48009
48010   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
48011   jresult = (int)result;
48012   return jresult;
48013 }
48014
48015
48016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
48017   int jresult ;
48018   int result;
48019
48020   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
48021   jresult = (int)result;
48022   return jresult;
48023 }
48024
48025
48026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
48027   int jresult ;
48028   int result;
48029
48030   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
48031   jresult = (int)result;
48032   return jresult;
48033 }
48034
48035
48036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
48037   int jresult ;
48038   int result;
48039
48040   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
48041   jresult = (int)result;
48042   return jresult;
48043 }
48044
48045
48046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
48047   int jresult ;
48048   int result;
48049
48050   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
48051   jresult = (int)result;
48052   return jresult;
48053 }
48054
48055
48056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
48057   int jresult ;
48058   int result;
48059
48060   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
48061   jresult = (int)result;
48062   return jresult;
48063 }
48064
48065
48066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
48067   int jresult ;
48068   int result;
48069
48070   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
48071   jresult = (int)result;
48072   return jresult;
48073 }
48074
48075
48076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
48077   int jresult ;
48078   int result;
48079
48080   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
48081   jresult = (int)result;
48082   return jresult;
48083 }
48084
48085
48086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
48087   int jresult ;
48088   int result;
48089
48090   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48091   jresult = (int)result;
48092   return jresult;
48093 }
48094
48095
48096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48097   int jresult ;
48098   int result;
48099
48100   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48101   jresult = (int)result;
48102   return jresult;
48103 }
48104
48105
48106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48107   int jresult ;
48108   int result;
48109
48110   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48111   jresult = (int)result;
48112   return jresult;
48113 }
48114
48115
48116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48117   int jresult ;
48118   int result;
48119
48120   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48121   jresult = (int)result;
48122   return jresult;
48123 }
48124
48125
48126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48127   int jresult ;
48128   int result;
48129
48130   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48131   jresult = (int)result;
48132   return jresult;
48133 }
48134
48135
48136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48137   void * jresult ;
48138   Dali::CameraActor::Property *result = 0 ;
48139
48140   {
48141     try {
48142       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48143     } catch (std::out_of_range& e) {
48144       {
48145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48146       };
48147     } catch (std::exception& e) {
48148       {
48149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48150       };
48151     } catch (Dali::DaliException e) {
48152       {
48153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48154       };
48155     } catch (...) {
48156       {
48157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48158       };
48159     }
48160   }
48161
48162   jresult = (void *)result;
48163   return jresult;
48164 }
48165
48166
48167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48168   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48169
48170   arg1 = (Dali::CameraActor::Property *)jarg1;
48171   {
48172     try {
48173       delete arg1;
48174     } catch (std::out_of_range& e) {
48175       {
48176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48177       };
48178     } catch (std::exception& e) {
48179       {
48180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48181       };
48182     } catch (Dali::DaliException e) {
48183       {
48184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48185       };
48186     } catch (...) {
48187       {
48188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48189       };
48190     }
48191   }
48192
48193 }
48194
48195
48196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48197   void * jresult ;
48198   Dali::CameraActor *result = 0 ;
48199
48200   {
48201     try {
48202       result = (Dali::CameraActor *)new Dali::CameraActor();
48203     } catch (std::out_of_range& e) {
48204       {
48205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48206       };
48207     } catch (std::exception& e) {
48208       {
48209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48210       };
48211     } catch (Dali::DaliException e) {
48212       {
48213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48214       };
48215     } catch (...) {
48216       {
48217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48218       };
48219     }
48220   }
48221
48222   jresult = (void *)result;
48223   return jresult;
48224 }
48225
48226
48227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48228   void * jresult ;
48229   Dali::CameraActor result;
48230
48231   {
48232     try {
48233       result = Dali::CameraActor::New();
48234     } catch (std::out_of_range& e) {
48235       {
48236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48237       };
48238     } catch (std::exception& e) {
48239       {
48240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48241       };
48242     } catch (Dali::DaliException e) {
48243       {
48244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48245       };
48246     } catch (...) {
48247       {
48248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48249       };
48250     }
48251   }
48252
48253   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48254   return jresult;
48255 }
48256
48257
48258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48259   void * jresult ;
48260   Dali::Size *arg1 = 0 ;
48261   Dali::CameraActor result;
48262
48263   arg1 = (Dali::Size *)jarg1;
48264   if (!arg1) {
48265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48266     return 0;
48267   }
48268   {
48269     try {
48270       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48271     } catch (std::out_of_range& e) {
48272       {
48273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48274       };
48275     } catch (std::exception& e) {
48276       {
48277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48278       };
48279     } catch (Dali::DaliException e) {
48280       {
48281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48282       };
48283     } catch (...) {
48284       {
48285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48286       };
48287     }
48288   }
48289
48290   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48291   return jresult;
48292 }
48293
48294
48295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48296   void * jresult ;
48297   Dali::BaseHandle arg1 ;
48298   Dali::BaseHandle *argp1 ;
48299   Dali::CameraActor result;
48300
48301   argp1 = (Dali::BaseHandle *)jarg1;
48302   if (!argp1) {
48303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48304     return 0;
48305   }
48306   arg1 = *argp1;
48307   {
48308     try {
48309       result = Dali::CameraActor::DownCast(arg1);
48310     } catch (std::out_of_range& e) {
48311       {
48312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48313       };
48314     } catch (std::exception& e) {
48315       {
48316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48317       };
48318     } catch (Dali::DaliException e) {
48319       {
48320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48321       };
48322     } catch (...) {
48323       {
48324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48325       };
48326     }
48327   }
48328
48329   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48330   return jresult;
48331 }
48332
48333
48334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48335   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48336
48337   arg1 = (Dali::CameraActor *)jarg1;
48338   {
48339     try {
48340       delete arg1;
48341     } catch (std::out_of_range& e) {
48342       {
48343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48344       };
48345     } catch (std::exception& e) {
48346       {
48347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48348       };
48349     } catch (Dali::DaliException e) {
48350       {
48351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48352       };
48353     } catch (...) {
48354       {
48355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48356       };
48357     }
48358   }
48359
48360 }
48361
48362
48363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48364   void * jresult ;
48365   Dali::CameraActor *arg1 = 0 ;
48366   Dali::CameraActor *result = 0 ;
48367
48368   arg1 = (Dali::CameraActor *)jarg1;
48369   if (!arg1) {
48370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48371     return 0;
48372   }
48373   {
48374     try {
48375       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48376     } catch (std::out_of_range& e) {
48377       {
48378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48379       };
48380     } catch (std::exception& e) {
48381       {
48382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48383       };
48384     } catch (Dali::DaliException e) {
48385       {
48386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48387       };
48388     } catch (...) {
48389       {
48390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48391       };
48392     }
48393   }
48394
48395   jresult = (void *)result;
48396   return jresult;
48397 }
48398
48399
48400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48401   void * jresult ;
48402   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48403   Dali::CameraActor *arg2 = 0 ;
48404   Dali::CameraActor *result = 0 ;
48405
48406   arg1 = (Dali::CameraActor *)jarg1;
48407   arg2 = (Dali::CameraActor *)jarg2;
48408   if (!arg2) {
48409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48410     return 0;
48411   }
48412   {
48413     try {
48414       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48415     } catch (std::out_of_range& e) {
48416       {
48417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48418       };
48419     } catch (std::exception& e) {
48420       {
48421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48422       };
48423     } catch (Dali::DaliException e) {
48424       {
48425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48426       };
48427     } catch (...) {
48428       {
48429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48430       };
48431     }
48432   }
48433
48434   jresult = (void *)result;
48435   return jresult;
48436 }
48437
48438
48439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48440   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48441   Dali::Camera::Type arg2 ;
48442
48443   arg1 = (Dali::CameraActor *)jarg1;
48444   arg2 = (Dali::Camera::Type)jarg2;
48445   {
48446     try {
48447       (arg1)->SetType(arg2);
48448     } catch (std::out_of_range& e) {
48449       {
48450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48451       };
48452     } catch (std::exception& e) {
48453       {
48454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48455       };
48456     } catch (Dali::DaliException e) {
48457       {
48458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48459       };
48460     } catch (...) {
48461       {
48462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48463       };
48464     }
48465   }
48466
48467 }
48468
48469
48470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48471   int jresult ;
48472   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48473   Dali::Camera::Type result;
48474
48475   arg1 = (Dali::CameraActor *)jarg1;
48476   {
48477     try {
48478       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48479     } catch (std::out_of_range& e) {
48480       {
48481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48482       };
48483     } catch (std::exception& e) {
48484       {
48485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48486       };
48487     } catch (Dali::DaliException e) {
48488       {
48489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48490       };
48491     } catch (...) {
48492       {
48493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48494       };
48495     }
48496   }
48497
48498   jresult = (int)result;
48499   return jresult;
48500 }
48501
48502
48503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48504   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48505   Dali::Camera::ProjectionMode arg2 ;
48506
48507   arg1 = (Dali::CameraActor *)jarg1;
48508   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48509   {
48510     try {
48511       (arg1)->SetProjectionMode(arg2);
48512     } catch (std::out_of_range& e) {
48513       {
48514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48515       };
48516     } catch (std::exception& e) {
48517       {
48518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48519       };
48520     } catch (Dali::DaliException e) {
48521       {
48522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48523       };
48524     } catch (...) {
48525       {
48526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48527       };
48528     }
48529   }
48530
48531 }
48532
48533
48534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48535   int jresult ;
48536   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48537   Dali::Camera::ProjectionMode result;
48538
48539   arg1 = (Dali::CameraActor *)jarg1;
48540   {
48541     try {
48542       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48543     } catch (std::out_of_range& e) {
48544       {
48545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48546       };
48547     } catch (std::exception& e) {
48548       {
48549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48550       };
48551     } catch (Dali::DaliException e) {
48552       {
48553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48554       };
48555     } catch (...) {
48556       {
48557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48558       };
48559     }
48560   }
48561
48562   jresult = (int)result;
48563   return jresult;
48564 }
48565
48566
48567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48568   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48569   float arg2 ;
48570
48571   arg1 = (Dali::CameraActor *)jarg1;
48572   arg2 = (float)jarg2;
48573   {
48574     try {
48575       (arg1)->SetFieldOfView(arg2);
48576     } catch (std::out_of_range& e) {
48577       {
48578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48579       };
48580     } catch (std::exception& e) {
48581       {
48582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48583       };
48584     } catch (Dali::DaliException e) {
48585       {
48586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48587       };
48588     } catch (...) {
48589       {
48590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48591       };
48592     }
48593   }
48594
48595 }
48596
48597
48598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48599   float jresult ;
48600   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48601   float result;
48602
48603   arg1 = (Dali::CameraActor *)jarg1;
48604   {
48605     try {
48606       result = (float)(arg1)->GetFieldOfView();
48607     } catch (std::out_of_range& e) {
48608       {
48609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48610       };
48611     } catch (std::exception& e) {
48612       {
48613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48614       };
48615     } catch (Dali::DaliException e) {
48616       {
48617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48618       };
48619     } catch (...) {
48620       {
48621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48622       };
48623     }
48624   }
48625
48626   jresult = result;
48627   return jresult;
48628 }
48629
48630
48631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48632   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48633   float arg2 ;
48634
48635   arg1 = (Dali::CameraActor *)jarg1;
48636   arg2 = (float)jarg2;
48637   {
48638     try {
48639       (arg1)->SetAspectRatio(arg2);
48640     } catch (std::out_of_range& e) {
48641       {
48642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48643       };
48644     } catch (std::exception& e) {
48645       {
48646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48647       };
48648     } catch (Dali::DaliException e) {
48649       {
48650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48651       };
48652     } catch (...) {
48653       {
48654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48655       };
48656     }
48657   }
48658
48659 }
48660
48661
48662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48663   float jresult ;
48664   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48665   float result;
48666
48667   arg1 = (Dali::CameraActor *)jarg1;
48668   {
48669     try {
48670       result = (float)(arg1)->GetAspectRatio();
48671     } catch (std::out_of_range& e) {
48672       {
48673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48674       };
48675     } catch (std::exception& e) {
48676       {
48677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48678       };
48679     } catch (Dali::DaliException e) {
48680       {
48681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48682       };
48683     } catch (...) {
48684       {
48685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48686       };
48687     }
48688   }
48689
48690   jresult = result;
48691   return jresult;
48692 }
48693
48694
48695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48696   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48697   float arg2 ;
48698
48699   arg1 = (Dali::CameraActor *)jarg1;
48700   arg2 = (float)jarg2;
48701   {
48702     try {
48703       (arg1)->SetNearClippingPlane(arg2);
48704     } catch (std::out_of_range& e) {
48705       {
48706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48707       };
48708     } catch (std::exception& e) {
48709       {
48710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48711       };
48712     } catch (Dali::DaliException e) {
48713       {
48714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48715       };
48716     } catch (...) {
48717       {
48718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48719       };
48720     }
48721   }
48722
48723 }
48724
48725
48726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48727   float jresult ;
48728   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48729   float result;
48730
48731   arg1 = (Dali::CameraActor *)jarg1;
48732   {
48733     try {
48734       result = (float)(arg1)->GetNearClippingPlane();
48735     } catch (std::out_of_range& e) {
48736       {
48737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48738       };
48739     } catch (std::exception& e) {
48740       {
48741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48742       };
48743     } catch (Dali::DaliException e) {
48744       {
48745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48746       };
48747     } catch (...) {
48748       {
48749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48750       };
48751     }
48752   }
48753
48754   jresult = result;
48755   return jresult;
48756 }
48757
48758
48759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48760   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48761   float arg2 ;
48762
48763   arg1 = (Dali::CameraActor *)jarg1;
48764   arg2 = (float)jarg2;
48765   {
48766     try {
48767       (arg1)->SetFarClippingPlane(arg2);
48768     } catch (std::out_of_range& e) {
48769       {
48770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48771       };
48772     } catch (std::exception& e) {
48773       {
48774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48775       };
48776     } catch (Dali::DaliException e) {
48777       {
48778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48779       };
48780     } catch (...) {
48781       {
48782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48783       };
48784     }
48785   }
48786
48787 }
48788
48789
48790 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48791   float jresult ;
48792   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48793   float result;
48794
48795   arg1 = (Dali::CameraActor *)jarg1;
48796   {
48797     try {
48798       result = (float)(arg1)->GetFarClippingPlane();
48799     } catch (std::out_of_range& e) {
48800       {
48801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48802       };
48803     } catch (std::exception& e) {
48804       {
48805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48806       };
48807     } catch (Dali::DaliException e) {
48808       {
48809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48810       };
48811     } catch (...) {
48812       {
48813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48814       };
48815     }
48816   }
48817
48818   jresult = result;
48819   return jresult;
48820 }
48821
48822
48823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48824   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48825   Dali::Vector3 *arg2 = 0 ;
48826
48827   arg1 = (Dali::CameraActor *)jarg1;
48828   arg2 = (Dali::Vector3 *)jarg2;
48829   if (!arg2) {
48830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48831     return ;
48832   }
48833   {
48834     try {
48835       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48836     } catch (std::out_of_range& e) {
48837       {
48838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48839       };
48840     } catch (std::exception& e) {
48841       {
48842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48843       };
48844     } catch (Dali::DaliException e) {
48845       {
48846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48847       };
48848     } catch (...) {
48849       {
48850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48851       };
48852     }
48853   }
48854
48855 }
48856
48857
48858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48859   void * jresult ;
48860   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48861   Dali::Vector3 result;
48862
48863   arg1 = (Dali::CameraActor *)jarg1;
48864   {
48865     try {
48866       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48867     } catch (std::out_of_range& e) {
48868       {
48869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48870       };
48871     } catch (std::exception& e) {
48872       {
48873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48874       };
48875     } catch (Dali::DaliException e) {
48876       {
48877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48878       };
48879     } catch (...) {
48880       {
48881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48882       };
48883     }
48884   }
48885
48886   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48887   return jresult;
48888 }
48889
48890
48891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48892   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48893   bool arg2 ;
48894
48895   arg1 = (Dali::CameraActor *)jarg1;
48896   arg2 = jarg2 ? true : false;
48897   {
48898     try {
48899       (arg1)->SetInvertYAxis(arg2);
48900     } catch (std::out_of_range& e) {
48901       {
48902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48903       };
48904     } catch (std::exception& e) {
48905       {
48906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48907       };
48908     } catch (Dali::DaliException e) {
48909       {
48910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48911       };
48912     } catch (...) {
48913       {
48914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48915       };
48916     }
48917   }
48918
48919 }
48920
48921
48922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48923   unsigned int jresult ;
48924   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48925   bool result;
48926
48927   arg1 = (Dali::CameraActor *)jarg1;
48928   {
48929     try {
48930       result = (bool)(arg1)->GetInvertYAxis();
48931     } catch (std::out_of_range& e) {
48932       {
48933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48934       };
48935     } catch (std::exception& e) {
48936       {
48937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48938       };
48939     } catch (Dali::DaliException e) {
48940       {
48941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48942       };
48943     } catch (...) {
48944       {
48945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48946       };
48947     }
48948   }
48949
48950   jresult = result;
48951   return jresult;
48952 }
48953
48954
48955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48956   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48957   Dali::Size *arg2 = 0 ;
48958
48959   arg1 = (Dali::CameraActor *)jarg1;
48960   arg2 = (Dali::Size *)jarg2;
48961   if (!arg2) {
48962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48963     return ;
48964   }
48965   {
48966     try {
48967       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48968     } catch (std::out_of_range& e) {
48969       {
48970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48971       };
48972     } catch (std::exception& e) {
48973       {
48974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48975       };
48976     } catch (Dali::DaliException e) {
48977       {
48978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48979       };
48980     } catch (...) {
48981       {
48982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48983       };
48984     }
48985   }
48986
48987 }
48988
48989
48990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48991   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48992   Dali::Size *arg2 = 0 ;
48993
48994   arg1 = (Dali::CameraActor *)jarg1;
48995   arg2 = (Dali::Size *)jarg2;
48996   if (!arg2) {
48997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48998     return ;
48999   }
49000   {
49001     try {
49002       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
49003     } catch (std::out_of_range& e) {
49004       {
49005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49006       };
49007     } catch (std::exception& e) {
49008       {
49009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49010       };
49011     } catch (Dali::DaliException e) {
49012       {
49013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49014       };
49015     } catch (...) {
49016       {
49017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49018       };
49019     }
49020   }
49021
49022 }
49023
49024
49025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
49026   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49027   float arg2 ;
49028   float arg3 ;
49029   float arg4 ;
49030   float arg5 ;
49031   float arg6 ;
49032   float arg7 ;
49033
49034   arg1 = (Dali::CameraActor *)jarg1;
49035   arg2 = (float)jarg2;
49036   arg3 = (float)jarg3;
49037   arg4 = (float)jarg4;
49038   arg5 = (float)jarg5;
49039   arg6 = (float)jarg6;
49040   arg7 = (float)jarg7;
49041   {
49042     try {
49043       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
49044     } catch (std::out_of_range& e) {
49045       {
49046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49047       };
49048     } catch (std::exception& e) {
49049       {
49050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49051       };
49052     } catch (Dali::DaliException e) {
49053       {
49054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49055       };
49056     } catch (...) {
49057       {
49058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49059       };
49060     }
49061   }
49062
49063 }
49064
49065
49066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
49067   void * jresult ;
49068   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49069
49070   {
49071     try {
49072       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
49073     } catch (std::out_of_range& e) {
49074       {
49075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49076       };
49077     } catch (std::exception& e) {
49078       {
49079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49080       };
49081     } catch (Dali::DaliException e) {
49082       {
49083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49084       };
49085     } catch (...) {
49086       {
49087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49088       };
49089     }
49090   }
49091
49092   jresult = (void *)result;
49093   return jresult;
49094 }
49095
49096
49097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49098   void * jresult ;
49099   std::string arg1 ;
49100   Dali::Property::Value arg2 ;
49101   Dali::Property::Value *argp2 ;
49102   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49103
49104   if (!jarg1) {
49105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49106     return 0;
49107   }
49108   (&arg1)->assign(jarg1);
49109   argp2 = (Dali::Property::Value *)jarg2;
49110   if (!argp2) {
49111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49112     return 0;
49113   }
49114   arg2 = *argp2;
49115   {
49116     try {
49117       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49118     } catch (std::out_of_range& e) {
49119       {
49120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49121       };
49122     } catch (std::exception& e) {
49123       {
49124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49125       };
49126     } catch (Dali::DaliException e) {
49127       {
49128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49129       };
49130     } catch (...) {
49131       {
49132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49133       };
49134     }
49135   }
49136
49137   jresult = (void *)result;
49138   return jresult;
49139 }
49140
49141
49142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49143   void * jresult ;
49144   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49145   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49146
49147   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49148   if (!arg1) {
49149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49150     return 0;
49151   }
49152   {
49153     try {
49154       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >((std::pair< std::string,Dali::Property::Value > const &)*arg1);
49155     } catch (std::out_of_range& e) {
49156       {
49157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49158       };
49159     } catch (std::exception& e) {
49160       {
49161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49162       };
49163     } catch (Dali::DaliException e) {
49164       {
49165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49166       };
49167     } catch (...) {
49168       {
49169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49170       };
49171     }
49172   }
49173
49174   jresult = (void *)result;
49175   return jresult;
49176 }
49177
49178
49179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49180   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49181   std::string *arg2 = 0 ;
49182
49183   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49184   if (!jarg2) {
49185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49186     return ;
49187   }
49188   std::string arg2_str(jarg2);
49189   arg2 = &arg2_str;
49190   if (arg1) (arg1)->first = *arg2;
49191
49192   //argout typemap for const std::string&
49193
49194 }
49195
49196
49197 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49198   char * jresult ;
49199   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49200   std::string *result = 0 ;
49201
49202   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49203   result = (std::string *) & ((arg1)->first);
49204   jresult = SWIG_csharp_string_callback(result->c_str());
49205   return jresult;
49206 }
49207
49208
49209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49210   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49211   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49212
49213   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49214   arg2 = (Dali::Property::Value *)jarg2;
49215   if (arg1) (arg1)->second = *arg2;
49216 }
49217
49218
49219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49220   void * jresult ;
49221   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49222   Dali::Property::Value *result = 0 ;
49223
49224   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49225   result = (Dali::Property::Value *)& ((arg1)->second);
49226   jresult = (void *)result;
49227   return jresult;
49228 }
49229
49230
49231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49232   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49233
49234   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49235   {
49236     try {
49237       delete arg1;
49238     } catch (std::out_of_range& e) {
49239       {
49240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49241       };
49242     } catch (std::exception& e) {
49243       {
49244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49245       };
49246     } catch (Dali::DaliException e) {
49247       {
49248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49249       };
49250     } catch (...) {
49251       {
49252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49253       };
49254     }
49255   }
49256
49257 }
49258
49259
49260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49261   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49262
49263   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49264   {
49265     try {
49266       (arg1)->clear();
49267     } catch (std::out_of_range& e) {
49268       {
49269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49270       };
49271     } catch (std::exception& e) {
49272       {
49273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49274       };
49275     } catch (Dali::DaliException e) {
49276       {
49277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49278       };
49279     } catch (...) {
49280       {
49281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49282       };
49283     }
49284   }
49285
49286 }
49287
49288
49289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49290   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49291   Dali::TouchPoint *arg2 = 0 ;
49292
49293   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49294   arg2 = (Dali::TouchPoint *)jarg2;
49295   if (!arg2) {
49296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49297     return ;
49298   }
49299   {
49300     try {
49301       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49302     } catch (std::out_of_range& e) {
49303       {
49304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49305       };
49306     } catch (std::exception& e) {
49307       {
49308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49309       };
49310     } catch (Dali::DaliException e) {
49311       {
49312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49313       };
49314     } catch (...) {
49315       {
49316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49317       };
49318     }
49319   }
49320
49321 }
49322
49323
49324 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49325   unsigned long jresult ;
49326   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49327   std::vector< Dali::TouchPoint >::size_type result;
49328
49329   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49330   {
49331     try {
49332       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49333     } catch (std::out_of_range& e) {
49334       {
49335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49336       };
49337     } catch (std::exception& e) {
49338       {
49339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49340       };
49341     } catch (Dali::DaliException e) {
49342       {
49343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49344       };
49345     } catch (...) {
49346       {
49347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49348       };
49349     }
49350   }
49351
49352   jresult = (unsigned long)result;
49353   return jresult;
49354 }
49355
49356
49357 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49358   unsigned long jresult ;
49359   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49360   std::vector< Dali::TouchPoint >::size_type result;
49361
49362   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49363   {
49364     try {
49365       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49366     } catch (std::out_of_range& e) {
49367       {
49368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49369       };
49370     } catch (std::exception& e) {
49371       {
49372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49373       };
49374     } catch (Dali::DaliException e) {
49375       {
49376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49377       };
49378     } catch (...) {
49379       {
49380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49381       };
49382     }
49383   }
49384
49385   jresult = (unsigned long)result;
49386   return jresult;
49387 }
49388
49389
49390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49391   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49392   std::vector< Dali::TouchPoint >::size_type arg2 ;
49393
49394   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49395   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49396   {
49397     try {
49398       (arg1)->reserve(arg2);
49399     } catch (std::out_of_range& e) {
49400       {
49401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49402       };
49403     } catch (std::exception& e) {
49404       {
49405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49406       };
49407     } catch (Dali::DaliException e) {
49408       {
49409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49410       };
49411     } catch (...) {
49412       {
49413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49414       };
49415     }
49416   }
49417
49418 }
49419
49420
49421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49422   void * jresult ;
49423   std::vector< Dali::TouchPoint > *result = 0 ;
49424
49425   {
49426     try {
49427       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49428     } catch (std::out_of_range& e) {
49429       {
49430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49431       };
49432     } catch (std::exception& e) {
49433       {
49434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49435       };
49436     } catch (Dali::DaliException e) {
49437       {
49438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49439       };
49440     } catch (...) {
49441       {
49442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49443       };
49444     }
49445   }
49446
49447   jresult = (void *)result;
49448   return jresult;
49449 }
49450
49451
49452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49453   void * jresult ;
49454   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49455   std::vector< Dali::TouchPoint > *result = 0 ;
49456
49457   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49458   if (!arg1) {
49459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49460     return 0;
49461   }
49462   {
49463     try {
49464       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49465     } catch (std::out_of_range& e) {
49466       {
49467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49468       };
49469     } catch (std::exception& e) {
49470       {
49471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49472       };
49473     } catch (Dali::DaliException e) {
49474       {
49475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49476       };
49477     } catch (...) {
49478       {
49479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49480       };
49481     }
49482   }
49483
49484   jresult = (void *)result;
49485   return jresult;
49486 }
49487
49488
49489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49490   void * jresult ;
49491   int arg1 ;
49492   std::vector< Dali::TouchPoint > *result = 0 ;
49493
49494   arg1 = (int)jarg1;
49495   {
49496     try {
49497       try {
49498         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49499       }
49500       catch(std::out_of_range &_e) {
49501         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49502         return 0;
49503       }
49504
49505     } catch (std::out_of_range& e) {
49506       {
49507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49508       };
49509     } catch (std::exception& e) {
49510       {
49511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49512       };
49513     } catch (Dali::DaliException e) {
49514       {
49515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49516       };
49517     } catch (...) {
49518       {
49519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49520       };
49521     }
49522   }
49523
49524   jresult = (void *)result;
49525   return jresult;
49526 }
49527
49528
49529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49530   void * jresult ;
49531   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49532   int arg2 ;
49533   SwigValueWrapper< Dali::TouchPoint > result;
49534
49535   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49536   arg2 = (int)jarg2;
49537   {
49538     try {
49539       try {
49540         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49541       }
49542       catch(std::out_of_range &_e) {
49543         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49544         return 0;
49545       }
49546
49547     } catch (std::out_of_range& e) {
49548       {
49549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49550       };
49551     } catch (std::exception& e) {
49552       {
49553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49554       };
49555     } catch (Dali::DaliException e) {
49556       {
49557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49558       };
49559     } catch (...) {
49560       {
49561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49562       };
49563     }
49564   }
49565
49566   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49567   return jresult;
49568 }
49569
49570
49571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49572   void * jresult ;
49573   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49574   int arg2 ;
49575   Dali::TouchPoint *result = 0 ;
49576
49577   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49578   arg2 = (int)jarg2;
49579   {
49580     try {
49581       try {
49582         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49583       }
49584       catch(std::out_of_range &_e) {
49585         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49586         return 0;
49587       }
49588
49589     } catch (std::out_of_range& e) {
49590       {
49591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49592       };
49593     } catch (std::exception& e) {
49594       {
49595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49596       };
49597     } catch (Dali::DaliException e) {
49598       {
49599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49600       };
49601     } catch (...) {
49602       {
49603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49604       };
49605     }
49606   }
49607
49608   jresult = (void *)result;
49609   return jresult;
49610 }
49611
49612
49613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49614   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49615   int arg2 ;
49616   Dali::TouchPoint *arg3 = 0 ;
49617
49618   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49619   arg2 = (int)jarg2;
49620   arg3 = (Dali::TouchPoint *)jarg3;
49621   if (!arg3) {
49622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49623     return ;
49624   }
49625   {
49626     try {
49627       try {
49628         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49629       }
49630       catch(std::out_of_range &_e) {
49631         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49632         return ;
49633       }
49634
49635     } catch (std::out_of_range& e) {
49636       {
49637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49638       };
49639     } catch (std::exception& e) {
49640       {
49641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49642       };
49643     } catch (Dali::DaliException e) {
49644       {
49645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49646       };
49647     } catch (...) {
49648       {
49649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49650       };
49651     }
49652   }
49653
49654 }
49655
49656
49657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49658   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49659   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49660
49661   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49662   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49663   if (!arg2) {
49664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49665     return ;
49666   }
49667   {
49668     try {
49669       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49670     } catch (std::out_of_range& e) {
49671       {
49672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49673       };
49674     } catch (std::exception& e) {
49675       {
49676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49677       };
49678     } catch (Dali::DaliException e) {
49679       {
49680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49681       };
49682     } catch (...) {
49683       {
49684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49685       };
49686     }
49687   }
49688
49689 }
49690
49691
49692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49693   void * jresult ;
49694   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49695   int arg2 ;
49696   int arg3 ;
49697   std::vector< Dali::TouchPoint > *result = 0 ;
49698
49699   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49700   arg2 = (int)jarg2;
49701   arg3 = (int)jarg3;
49702   {
49703     try {
49704       try {
49705         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49706       }
49707       catch(std::out_of_range &_e) {
49708         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49709         return 0;
49710       }
49711       catch(std::invalid_argument &_e) {
49712         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49713         return 0;
49714       }
49715
49716     } catch (std::out_of_range& e) {
49717       {
49718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49719       };
49720     } catch (std::exception& e) {
49721       {
49722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49723       };
49724     } catch (Dali::DaliException e) {
49725       {
49726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49727       };
49728     } catch (...) {
49729       {
49730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49731       };
49732     }
49733   }
49734
49735   jresult = (void *)result;
49736   return jresult;
49737 }
49738
49739
49740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49741   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49742   int arg2 ;
49743   Dali::TouchPoint *arg3 = 0 ;
49744
49745   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49746   arg2 = (int)jarg2;
49747   arg3 = (Dali::TouchPoint *)jarg3;
49748   if (!arg3) {
49749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49750     return ;
49751   }
49752   {
49753     try {
49754       try {
49755         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49756       }
49757       catch(std::out_of_range &_e) {
49758         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49759         return ;
49760       }
49761
49762     } catch (std::out_of_range& e) {
49763       {
49764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49765       };
49766     } catch (std::exception& e) {
49767       {
49768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49769       };
49770     } catch (Dali::DaliException e) {
49771       {
49772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49773       };
49774     } catch (...) {
49775       {
49776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49777       };
49778     }
49779   }
49780
49781 }
49782
49783
49784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49785   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49786   int arg2 ;
49787   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49788
49789   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49790   arg2 = (int)jarg2;
49791   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49792   if (!arg3) {
49793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49794     return ;
49795   }
49796   {
49797     try {
49798       try {
49799         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49800       }
49801       catch(std::out_of_range &_e) {
49802         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49803         return ;
49804       }
49805
49806     } catch (std::out_of_range& e) {
49807       {
49808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49809       };
49810     } catch (std::exception& e) {
49811       {
49812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49813       };
49814     } catch (Dali::DaliException e) {
49815       {
49816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49817       };
49818     } catch (...) {
49819       {
49820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49821       };
49822     }
49823   }
49824
49825 }
49826
49827
49828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49829   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49830   int arg2 ;
49831
49832   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49833   arg2 = (int)jarg2;
49834   {
49835     try {
49836       try {
49837         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49838       }
49839       catch(std::out_of_range &_e) {
49840         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49841         return ;
49842       }
49843
49844     } catch (std::out_of_range& e) {
49845       {
49846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49847       };
49848     } catch (std::exception& e) {
49849       {
49850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49851       };
49852     } catch (Dali::DaliException e) {
49853       {
49854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49855       };
49856     } catch (...) {
49857       {
49858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49859       };
49860     }
49861   }
49862
49863 }
49864
49865
49866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49867   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49868   int arg2 ;
49869   int arg3 ;
49870
49871   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49872   arg2 = (int)jarg2;
49873   arg3 = (int)jarg3;
49874   {
49875     try {
49876       try {
49877         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49878       }
49879       catch(std::out_of_range &_e) {
49880         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49881         return ;
49882       }
49883       catch(std::invalid_argument &_e) {
49884         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49885         return ;
49886       }
49887
49888     } catch (std::out_of_range& e) {
49889       {
49890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49891       };
49892     } catch (std::exception& e) {
49893       {
49894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49895       };
49896     } catch (Dali::DaliException e) {
49897       {
49898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49899       };
49900     } catch (...) {
49901       {
49902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49903       };
49904     }
49905   }
49906
49907 }
49908
49909
49910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49911   void * jresult ;
49912   Dali::TouchPoint *arg1 = 0 ;
49913   int arg2 ;
49914   std::vector< Dali::TouchPoint > *result = 0 ;
49915
49916   arg1 = (Dali::TouchPoint *)jarg1;
49917   if (!arg1) {
49918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49919     return 0;
49920   }
49921   arg2 = (int)jarg2;
49922   {
49923     try {
49924       try {
49925         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49926       }
49927       catch(std::out_of_range &_e) {
49928         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49929         return 0;
49930       }
49931
49932     } catch (std::out_of_range& e) {
49933       {
49934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49935       };
49936     } catch (std::exception& e) {
49937       {
49938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49939       };
49940     } catch (Dali::DaliException e) {
49941       {
49942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49943       };
49944     } catch (...) {
49945       {
49946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49947       };
49948     }
49949   }
49950
49951   jresult = (void *)result;
49952   return jresult;
49953 }
49954
49955
49956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49957   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49958
49959   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49960   {
49961     try {
49962       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49963     } catch (std::out_of_range& e) {
49964       {
49965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49966       };
49967     } catch (std::exception& e) {
49968       {
49969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49970       };
49971     } catch (Dali::DaliException e) {
49972       {
49973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49974       };
49975     } catch (...) {
49976       {
49977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49978       };
49979     }
49980   }
49981
49982 }
49983
49984
49985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49986   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49987   int arg2 ;
49988   int arg3 ;
49989
49990   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49991   arg2 = (int)jarg2;
49992   arg3 = (int)jarg3;
49993   {
49994     try {
49995       try {
49996         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49997       }
49998       catch(std::out_of_range &_e) {
49999         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50000         return ;
50001       }
50002       catch(std::invalid_argument &_e) {
50003         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
50004         return ;
50005       }
50006
50007     } catch (std::out_of_range& e) {
50008       {
50009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50010       };
50011     } catch (std::exception& e) {
50012       {
50013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50014       };
50015     } catch (Dali::DaliException e) {
50016       {
50017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50018       };
50019     } catch (...) {
50020       {
50021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50022       };
50023     }
50024   }
50025
50026 }
50027
50028
50029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
50030   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50031   int arg2 ;
50032   std::vector< Dali::TouchPoint > *arg3 = 0 ;
50033
50034   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50035   arg2 = (int)jarg2;
50036   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
50037   if (!arg3) {
50038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
50039     return ;
50040   }
50041   {
50042     try {
50043       try {
50044         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
50045       }
50046       catch(std::out_of_range &_e) {
50047         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50048         return ;
50049       }
50050
50051     } catch (std::out_of_range& e) {
50052       {
50053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50054       };
50055     } catch (std::exception& e) {
50056       {
50057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50058       };
50059     } catch (Dali::DaliException e) {
50060       {
50061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50062       };
50063     } catch (...) {
50064       {
50065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50066       };
50067     }
50068   }
50069
50070 }
50071
50072
50073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
50074   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50075
50076   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50077   {
50078     try {
50079       delete arg1;
50080     } catch (std::out_of_range& e) {
50081       {
50082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50083       };
50084     } catch (std::exception& e) {
50085       {
50086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50087       };
50088     } catch (Dali::DaliException e) {
50089       {
50090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50091       };
50092     } catch (...) {
50093       {
50094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50095       };
50096     }
50097   }
50098
50099 }
50100
50101
50102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50103   void * jresult ;
50104   Dali::Rect< int > *result = 0 ;
50105
50106   {
50107     try {
50108       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50109     } catch (std::out_of_range& e) {
50110       {
50111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50112       };
50113     } catch (std::exception& e) {
50114       {
50115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50116       };
50117     } catch (Dali::DaliException e) {
50118       {
50119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50120       };
50121     } catch (...) {
50122       {
50123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50124       };
50125     }
50126   }
50127
50128   jresult = (void *)result;
50129   return jresult;
50130 }
50131
50132
50133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50134   void * jresult ;
50135   int arg1 ;
50136   int arg2 ;
50137   int arg3 ;
50138   int arg4 ;
50139   Dali::Rect< int > *result = 0 ;
50140
50141   arg1 = (int)jarg1;
50142   arg2 = (int)jarg2;
50143   arg3 = (int)jarg3;
50144   arg4 = (int)jarg4;
50145   {
50146     try {
50147       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50148     } catch (std::out_of_range& e) {
50149       {
50150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50151       };
50152     } catch (std::exception& e) {
50153       {
50154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50155       };
50156     } catch (Dali::DaliException e) {
50157       {
50158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50159       };
50160     } catch (...) {
50161       {
50162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50163       };
50164     }
50165   }
50166
50167   jresult = (void *)result;
50168   return jresult;
50169 }
50170
50171
50172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50173   void * jresult ;
50174   Dali::Rect< int > *arg1 = 0 ;
50175   Dali::Rect< int > *result = 0 ;
50176
50177   arg1 = (Dali::Rect< int > *)jarg1;
50178   if (!arg1) {
50179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50180     return 0;
50181   }
50182   {
50183     try {
50184       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50185     } catch (std::out_of_range& e) {
50186       {
50187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50188       };
50189     } catch (std::exception& e) {
50190       {
50191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50192       };
50193     } catch (Dali::DaliException e) {
50194       {
50195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50196       };
50197     } catch (...) {
50198       {
50199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50200       };
50201     }
50202   }
50203
50204   jresult = (void *)result;
50205   return jresult;
50206 }
50207
50208
50209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50210   void * jresult ;
50211   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50212   Dali::Rect< int > *arg2 = 0 ;
50213   Dali::Rect< int > *result = 0 ;
50214
50215   arg1 = (Dali::Rect< int > *)jarg1;
50216   arg2 = (Dali::Rect< int > *)jarg2;
50217   if (!arg2) {
50218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50219     return 0;
50220   }
50221   {
50222     try {
50223       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50224     } catch (std::out_of_range& e) {
50225       {
50226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50227       };
50228     } catch (std::exception& e) {
50229       {
50230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50231       };
50232     } catch (Dali::DaliException e) {
50233       {
50234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50235       };
50236     } catch (...) {
50237       {
50238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50239       };
50240     }
50241   }
50242
50243   jresult = (void *)result;
50244   return jresult;
50245 }
50246
50247
50248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50249   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50250   int arg2 ;
50251   int arg3 ;
50252   int arg4 ;
50253   int arg5 ;
50254
50255   arg1 = (Dali::Rect< int > *)jarg1;
50256   arg2 = (int)jarg2;
50257   arg3 = (int)jarg3;
50258   arg4 = (int)jarg4;
50259   arg5 = (int)jarg5;
50260   {
50261     try {
50262       (arg1)->Set(arg2,arg3,arg4,arg5);
50263     } catch (std::out_of_range& e) {
50264       {
50265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50266       };
50267     } catch (std::exception& e) {
50268       {
50269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50270       };
50271     } catch (Dali::DaliException e) {
50272       {
50273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50274       };
50275     } catch (...) {
50276       {
50277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50278       };
50279     }
50280   }
50281
50282 }
50283
50284
50285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50286   unsigned int jresult ;
50287   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50288   bool result;
50289
50290   arg1 = (Dali::Rect< int > *)jarg1;
50291   {
50292     try {
50293       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50294     } catch (std::out_of_range& e) {
50295       {
50296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50297       };
50298     } catch (std::exception& e) {
50299       {
50300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50301       };
50302     } catch (Dali::DaliException e) {
50303       {
50304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50305       };
50306     } catch (...) {
50307       {
50308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50309       };
50310     }
50311   }
50312
50313   jresult = result;
50314   return jresult;
50315 }
50316
50317
50318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50319   int jresult ;
50320   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50321   int result;
50322
50323   arg1 = (Dali::Rect< int > *)jarg1;
50324   {
50325     try {
50326       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50327     } catch (std::out_of_range& e) {
50328       {
50329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50330       };
50331     } catch (std::exception& e) {
50332       {
50333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50334       };
50335     } catch (Dali::DaliException e) {
50336       {
50337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50338       };
50339     } catch (...) {
50340       {
50341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50342       };
50343     }
50344   }
50345
50346   jresult = result;
50347   return jresult;
50348 }
50349
50350
50351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50352   int jresult ;
50353   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50354   int result;
50355
50356   arg1 = (Dali::Rect< int > *)jarg1;
50357   {
50358     try {
50359       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50360     } catch (std::out_of_range& e) {
50361       {
50362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50363       };
50364     } catch (std::exception& e) {
50365       {
50366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50367       };
50368     } catch (Dali::DaliException e) {
50369       {
50370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50371       };
50372     } catch (...) {
50373       {
50374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50375       };
50376     }
50377   }
50378
50379   jresult = result;
50380   return jresult;
50381 }
50382
50383
50384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50385   int jresult ;
50386   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50387   int result;
50388
50389   arg1 = (Dali::Rect< int > *)jarg1;
50390   {
50391     try {
50392       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50393     } catch (std::out_of_range& e) {
50394       {
50395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50396       };
50397     } catch (std::exception& e) {
50398       {
50399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50400       };
50401     } catch (Dali::DaliException e) {
50402       {
50403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50404       };
50405     } catch (...) {
50406       {
50407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50408       };
50409     }
50410   }
50411
50412   jresult = result;
50413   return jresult;
50414 }
50415
50416
50417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50418   int jresult ;
50419   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50420   int result;
50421
50422   arg1 = (Dali::Rect< int > *)jarg1;
50423   {
50424     try {
50425       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50426     } catch (std::out_of_range& e) {
50427       {
50428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50429       };
50430     } catch (std::exception& e) {
50431       {
50432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50433       };
50434     } catch (Dali::DaliException e) {
50435       {
50436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50437       };
50438     } catch (...) {
50439       {
50440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50441       };
50442     }
50443   }
50444
50445   jresult = result;
50446   return jresult;
50447 }
50448
50449
50450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50451   int jresult ;
50452   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50453   int result;
50454
50455   arg1 = (Dali::Rect< int > *)jarg1;
50456   {
50457     try {
50458       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50459     } catch (std::out_of_range& e) {
50460       {
50461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50462       };
50463     } catch (std::exception& e) {
50464       {
50465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50466       };
50467     } catch (Dali::DaliException e) {
50468       {
50469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50470       };
50471     } catch (...) {
50472       {
50473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50474       };
50475     }
50476   }
50477
50478   jresult = result;
50479   return jresult;
50480 }
50481
50482
50483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50484   unsigned int jresult ;
50485   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50486   Dali::Rect< int > *arg2 = 0 ;
50487   bool result;
50488
50489   arg1 = (Dali::Rect< int > *)jarg1;
50490   arg2 = (Dali::Rect< int > *)jarg2;
50491   if (!arg2) {
50492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50493     return 0;
50494   }
50495   {
50496     try {
50497       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50498     } catch (std::out_of_range& e) {
50499       {
50500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50501       };
50502     } catch (std::exception& e) {
50503       {
50504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50505       };
50506     } catch (Dali::DaliException e) {
50507       {
50508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50509       };
50510     } catch (...) {
50511       {
50512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50513       };
50514     }
50515   }
50516
50517   jresult = result;
50518   return jresult;
50519 }
50520
50521
50522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50523   unsigned int jresult ;
50524   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50525   Dali::Rect< int > *arg2 = 0 ;
50526   bool result;
50527
50528   arg1 = (Dali::Rect< int > *)jarg1;
50529   arg2 = (Dali::Rect< int > *)jarg2;
50530   if (!arg2) {
50531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50532     return 0;
50533   }
50534   {
50535     try {
50536       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50537     } catch (std::out_of_range& e) {
50538       {
50539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50540       };
50541     } catch (std::exception& e) {
50542       {
50543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50544       };
50545     } catch (Dali::DaliException e) {
50546       {
50547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50548       };
50549     } catch (...) {
50550       {
50551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50552       };
50553     }
50554   }
50555
50556   jresult = result;
50557   return jresult;
50558 }
50559
50560
50561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50562   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50563   int arg2 ;
50564
50565   arg1 = (Dali::Rect< int > *)jarg1;
50566   arg2 = (int)jarg2;
50567   if (arg1) (arg1)->x = arg2;
50568 }
50569
50570
50571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50572   int jresult ;
50573   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50574   int result;
50575
50576   arg1 = (Dali::Rect< int > *)jarg1;
50577   result = (int) ((arg1)->x);
50578   jresult = result;
50579   return jresult;
50580 }
50581
50582
50583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50584   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50585   int arg2 ;
50586
50587   arg1 = (Dali::Rect< int > *)jarg1;
50588   arg2 = (int)jarg2;
50589   if (arg1) (arg1)->left = arg2;
50590 }
50591
50592
50593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50594   int jresult ;
50595   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50596   int result;
50597
50598   arg1 = (Dali::Rect< int > *)jarg1;
50599   result = (int) ((arg1)->left);
50600   jresult = result;
50601   return jresult;
50602 }
50603
50604
50605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50606   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50607   int arg2 ;
50608
50609   arg1 = (Dali::Rect< int > *)jarg1;
50610   arg2 = (int)jarg2;
50611   if (arg1) (arg1)->y = arg2;
50612 }
50613
50614
50615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50616   int jresult ;
50617   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50618   int result;
50619
50620   arg1 = (Dali::Rect< int > *)jarg1;
50621   result = (int) ((arg1)->y);
50622   jresult = result;
50623   return jresult;
50624 }
50625
50626
50627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50628   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50629   int arg2 ;
50630
50631   arg1 = (Dali::Rect< int > *)jarg1;
50632   arg2 = (int)jarg2;
50633   if (arg1) (arg1)->right = arg2;
50634 }
50635
50636
50637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50638   int jresult ;
50639   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50640   int result;
50641
50642   arg1 = (Dali::Rect< int > *)jarg1;
50643   result = (int) ((arg1)->right);
50644   jresult = result;
50645   return jresult;
50646 }
50647
50648
50649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50650   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50651   int arg2 ;
50652
50653   arg1 = (Dali::Rect< int > *)jarg1;
50654   arg2 = (int)jarg2;
50655   if (arg1) (arg1)->width = arg2;
50656 }
50657
50658
50659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50660   int jresult ;
50661   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50662   int result;
50663
50664   arg1 = (Dali::Rect< int > *)jarg1;
50665   result = (int) ((arg1)->width);
50666   jresult = result;
50667   return jresult;
50668 }
50669
50670
50671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50672   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50673   int arg2 ;
50674
50675   arg1 = (Dali::Rect< int > *)jarg1;
50676   arg2 = (int)jarg2;
50677   if (arg1) (arg1)->bottom = arg2;
50678 }
50679
50680
50681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50682   int jresult ;
50683   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50684   int result;
50685
50686   arg1 = (Dali::Rect< int > *)jarg1;
50687   result = (int) ((arg1)->bottom);
50688   jresult = result;
50689   return jresult;
50690 }
50691
50692
50693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50694   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50695   int arg2 ;
50696
50697   arg1 = (Dali::Rect< int > *)jarg1;
50698   arg2 = (int)jarg2;
50699   if (arg1) (arg1)->height = arg2;
50700 }
50701
50702
50703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50704   int jresult ;
50705   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50706   int result;
50707
50708   arg1 = (Dali::Rect< int > *)jarg1;
50709   result = (int) ((arg1)->height);
50710   jresult = result;
50711   return jresult;
50712 }
50713
50714
50715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50716   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50717   int arg2 ;
50718
50719   arg1 = (Dali::Rect< int > *)jarg1;
50720   arg2 = (int)jarg2;
50721   if (arg1) (arg1)->top = arg2;
50722 }
50723
50724
50725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50726   int jresult ;
50727   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50728   int result;
50729
50730   arg1 = (Dali::Rect< int > *)jarg1;
50731   result = (int) ((arg1)->top);
50732   jresult = result;
50733   return jresult;
50734 }
50735
50736
50737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50738   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50739
50740   arg1 = (Dali::Rect< int > *)jarg1;
50741   {
50742     try {
50743       delete arg1;
50744     } catch (std::out_of_range& e) {
50745       {
50746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50747       };
50748     } catch (std::exception& e) {
50749       {
50750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50751       };
50752     } catch (Dali::DaliException e) {
50753       {
50754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50755       };
50756     } catch (...) {
50757       {
50758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50759       };
50760     }
50761   }
50762
50763 }
50764
50765
50766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50767   void * jresult ;
50768   Dali::Rect< float > *result = 0 ;
50769
50770   {
50771     try {
50772       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50773     } catch (std::out_of_range& e) {
50774       {
50775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50776       };
50777     } catch (std::exception& e) {
50778       {
50779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50780       };
50781     } catch (Dali::DaliException e) {
50782       {
50783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50784       };
50785     } catch (...) {
50786       {
50787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50788       };
50789     }
50790   }
50791
50792   jresult = (void *)result;
50793   return jresult;
50794 }
50795
50796
50797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50798   void * jresult ;
50799   float arg1 ;
50800   float arg2 ;
50801   float arg3 ;
50802   float arg4 ;
50803   Dali::Rect< float > *result = 0 ;
50804
50805   arg1 = (float)jarg1;
50806   arg2 = (float)jarg2;
50807   arg3 = (float)jarg4;
50808   arg4 = (float)jarg3;
50809   {
50810     try {
50811       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50812     } catch (std::out_of_range& e) {
50813       {
50814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50815       };
50816     } catch (std::exception& e) {
50817       {
50818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50819       };
50820     } catch (Dali::DaliException e) {
50821       {
50822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50823       };
50824     } catch (...) {
50825       {
50826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50827       };
50828     }
50829   }
50830
50831   jresult = (void *)result;
50832   return jresult;
50833 }
50834
50835
50836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50837   void * jresult ;
50838   Dali::Rect< float > *arg1 = 0 ;
50839   Dali::Rect< float > *result = 0 ;
50840
50841   arg1 = (Dali::Rect< float > *)jarg1;
50842   if (!arg1) {
50843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50844     return 0;
50845   }
50846   {
50847     try {
50848       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50849     } catch (std::out_of_range& e) {
50850       {
50851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50852       };
50853     } catch (std::exception& e) {
50854       {
50855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50856       };
50857     } catch (Dali::DaliException e) {
50858       {
50859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50860       };
50861     } catch (...) {
50862       {
50863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50864       };
50865     }
50866   }
50867
50868   jresult = (void *)result;
50869   return jresult;
50870 }
50871
50872
50873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50874   void * jresult ;
50875   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50876   Dali::Rect< float > *arg2 = 0 ;
50877   Dali::Rect< float > *result = 0 ;
50878
50879   arg1 = (Dali::Rect< float > *)jarg1;
50880   arg2 = (Dali::Rect< float > *)jarg2;
50881   if (!arg2) {
50882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50883     return 0;
50884   }
50885   {
50886     try {
50887       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50888     } catch (std::out_of_range& e) {
50889       {
50890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50891       };
50892     } catch (std::exception& e) {
50893       {
50894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50895       };
50896     } catch (Dali::DaliException e) {
50897       {
50898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50899       };
50900     } catch (...) {
50901       {
50902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50903       };
50904     }
50905   }
50906
50907   jresult = (void *)result;
50908   return jresult;
50909 }
50910
50911
50912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50913   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50914   float arg2 ;
50915   float arg3 ;
50916   float arg4 ;
50917   float arg5 ;
50918
50919   arg1 = (Dali::Rect< float > *)jarg1;
50920   arg2 = (float)jarg2;
50921   arg3 = (float)jarg3;
50922   arg4 = (float)jarg5;
50923   arg5 = (float)jarg4;
50924   {
50925     try {
50926       (arg1)->Set(arg2,arg3,arg4,arg5);
50927     } catch (std::out_of_range& e) {
50928       {
50929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50930       };
50931     } catch (std::exception& e) {
50932       {
50933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50934       };
50935     } catch (Dali::DaliException e) {
50936       {
50937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50938       };
50939     } catch (...) {
50940       {
50941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50942       };
50943     }
50944   }
50945
50946 }
50947
50948
50949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50950   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50951   float arg2 ;
50952
50953   arg1 = (Dali::Rect< float > *)jarg1;
50954   arg2 = (float)jarg2;
50955   if (arg1) (arg1)->left = arg2;
50956 }
50957
50958
50959 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50960   float jresult ;
50961   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50962   float result;
50963
50964   arg1 = (Dali::Rect< float > *)jarg1;
50965   result = (float) ((arg1)->left);
50966   jresult = result;
50967   return jresult;
50968 }
50969
50970
50971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50972   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50973   float arg2 ;
50974
50975   arg1 = (Dali::Rect< float > *)jarg1;
50976   arg2 = (float)jarg2;
50977   if (arg1) (arg1)->left = arg2;
50978 }
50979
50980
50981 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50982   float jresult ;
50983   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50984   float result;
50985
50986   arg1 = (Dali::Rect< float > *)jarg1;
50987   result = (float) ((arg1)->left);
50988   jresult = result;
50989   return jresult;
50990 }
50991
50992
50993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50994   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50995   float arg2 ;
50996
50997   arg1 = (Dali::Rect< float > *)jarg1;
50998   arg2 = (float)jarg2;
50999   if (arg1) (arg1)->right = arg2;
51000 }
51001
51002
51003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
51004   float jresult ;
51005   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51006   float result;
51007
51008   arg1 = (Dali::Rect< float > *)jarg1;
51009   result = (float) ((arg1)->right);
51010   jresult = result;
51011   return jresult;
51012 }
51013
51014
51015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
51016   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51017   float arg2 ;
51018
51019   arg1 = (Dali::Rect< float > *)jarg1;
51020   arg2 = (float)jarg2;
51021   if (arg1) (arg1)->right = arg2;
51022 }
51023
51024
51025 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
51026   float jresult ;
51027   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51028   float result;
51029
51030   arg1 = (Dali::Rect< float > *)jarg1;
51031   result = (float) ((arg1)->right);
51032   jresult = result;
51033   return jresult;
51034 }
51035
51036
51037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
51038   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51039   float arg2 ;
51040
51041   arg1 = (Dali::Rect< float > *)jarg1;
51042   arg2 = (float)jarg2;
51043   if (arg1) (arg1)->bottom = arg2;
51044 }
51045
51046
51047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
51048   float jresult ;
51049   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51050   float result;
51051
51052   arg1 = (Dali::Rect< float > *)jarg1;
51053   result = (float) ((arg1)->bottom);
51054   jresult = result;
51055   return jresult;
51056 }
51057
51058
51059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
51060   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51061   float arg2 ;
51062
51063   arg1 = (Dali::Rect< float > *)jarg1;
51064   arg2 = (float)jarg2;
51065   if (arg1) (arg1)->top = arg2;
51066 }
51067
51068
51069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
51070   float jresult ;
51071   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51072   float result;
51073
51074   arg1 = (Dali::Rect< float > *)jarg1;
51075   result = (float) ((arg1)->top);
51076   jresult = result;
51077   return jresult;
51078 }
51079
51080
51081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
51082   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51083
51084   arg1 = (Dali::Rect< float > *)jarg1;
51085   {
51086     try {
51087       delete arg1;
51088     } catch (std::out_of_range& e) {
51089       {
51090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51091       };
51092     } catch (std::exception& e) {
51093       {
51094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51095       };
51096     } catch (Dali::DaliException e) {
51097       {
51098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51099       };
51100     } catch (...) {
51101       {
51102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51103       };
51104     }
51105   }
51106
51107 }
51108
51109
51110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51111   int jresult ;
51112   int result;
51113
51114   result = (int)Dali::Vector< int >::BaseType;
51115   jresult = (int)result;
51116   return jresult;
51117 }
51118
51119
51120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51121   void * jresult ;
51122   Dali::Vector< int > *result = 0 ;
51123
51124   {
51125     try {
51126       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51127     } catch (std::out_of_range& e) {
51128       {
51129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51130       };
51131     } catch (std::exception& e) {
51132       {
51133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51134       };
51135     } catch (Dali::DaliException e) {
51136       {
51137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51138       };
51139     } catch (...) {
51140       {
51141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51142       };
51143     }
51144   }
51145
51146   jresult = (void *)result;
51147   return jresult;
51148 }
51149
51150
51151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51152   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51153
51154   arg1 = (Dali::Vector< int > *)jarg1;
51155   {
51156     try {
51157       delete arg1;
51158     } catch (std::out_of_range& e) {
51159       {
51160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51161       };
51162     } catch (std::exception& e) {
51163       {
51164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51165       };
51166     } catch (Dali::DaliException e) {
51167       {
51168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51169       };
51170     } catch (...) {
51171       {
51172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51173       };
51174     }
51175   }
51176
51177 }
51178
51179
51180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51181   void * jresult ;
51182   Dali::Vector< int > *arg1 = 0 ;
51183   Dali::Vector< int > *result = 0 ;
51184
51185   arg1 = (Dali::Vector< int > *)jarg1;
51186   if (!arg1) {
51187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51188     return 0;
51189   }
51190   {
51191     try {
51192       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51193     } catch (std::out_of_range& e) {
51194       {
51195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51196       };
51197     } catch (std::exception& e) {
51198       {
51199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51200       };
51201     } catch (Dali::DaliException e) {
51202       {
51203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51204       };
51205     } catch (...) {
51206       {
51207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51208       };
51209     }
51210   }
51211
51212   jresult = (void *)result;
51213   return jresult;
51214 }
51215
51216
51217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51218   void * jresult ;
51219   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51220   Dali::Vector< int > *arg2 = 0 ;
51221   Dali::Vector< int > *result = 0 ;
51222
51223   arg1 = (Dali::Vector< int > *)jarg1;
51224   arg2 = (Dali::Vector< int > *)jarg2;
51225   if (!arg2) {
51226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51227     return 0;
51228   }
51229   {
51230     try {
51231       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51232     } catch (std::out_of_range& e) {
51233       {
51234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51235       };
51236     } catch (std::exception& e) {
51237       {
51238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51239       };
51240     } catch (Dali::DaliException e) {
51241       {
51242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51243       };
51244     } catch (...) {
51245       {
51246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51247       };
51248     }
51249   }
51250
51251   jresult = (void *)result;
51252   return jresult;
51253 }
51254
51255
51256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51257   void * jresult ;
51258   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51259   Dali::Vector< int >::Iterator result;
51260
51261   arg1 = (Dali::Vector< int > *)jarg1;
51262   {
51263     try {
51264       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51265     } catch (std::out_of_range& e) {
51266       {
51267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51268       };
51269     } catch (std::exception& e) {
51270       {
51271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51272       };
51273     } catch (Dali::DaliException e) {
51274       {
51275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51276       };
51277     } catch (...) {
51278       {
51279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51280       };
51281     }
51282   }
51283
51284   jresult = (void *)result;
51285   return jresult;
51286 }
51287
51288
51289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51290   void * jresult ;
51291   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51292   Dali::Vector< int >::Iterator result;
51293
51294   arg1 = (Dali::Vector< int > *)jarg1;
51295   {
51296     try {
51297       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51298     } catch (std::out_of_range& e) {
51299       {
51300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51301       };
51302     } catch (std::exception& e) {
51303       {
51304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51305       };
51306     } catch (Dali::DaliException e) {
51307       {
51308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51309       };
51310     } catch (...) {
51311       {
51312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51313       };
51314     }
51315   }
51316
51317   jresult = (void *)result;
51318   return jresult;
51319 }
51320
51321
51322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51323   void * jresult ;
51324   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51325   Dali::Vector< int >::SizeType arg2 ;
51326   Dali::Vector< int >::ItemType *result = 0 ;
51327
51328   arg1 = (Dali::Vector< int > *)jarg1;
51329   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51330   {
51331     try {
51332       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51333     } catch (std::out_of_range& e) {
51334       {
51335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51336       };
51337     } catch (std::exception& e) {
51338       {
51339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51340       };
51341     } catch (Dali::DaliException e) {
51342       {
51343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51344       };
51345     } catch (...) {
51346       {
51347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51348       };
51349     }
51350   }
51351
51352   jresult = (void *)result;
51353   return jresult;
51354 }
51355
51356
51357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51358   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51359   Dali::Vector< int >::ItemType *arg2 = 0 ;
51360   Dali::Vector< int >::ItemType temp2 ;
51361
51362   arg1 = (Dali::Vector< int > *)jarg1;
51363   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51364   arg2 = &temp2;
51365   {
51366     try {
51367       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51368     } catch (std::out_of_range& e) {
51369       {
51370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51371       };
51372     } catch (std::exception& e) {
51373       {
51374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51375       };
51376     } catch (Dali::DaliException e) {
51377       {
51378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51379       };
51380     } catch (...) {
51381       {
51382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51383       };
51384     }
51385   }
51386
51387 }
51388
51389
51390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51391   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51392   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51393   Dali::Vector< int >::ItemType *arg3 = 0 ;
51394   Dali::Vector< int >::ItemType temp3 ;
51395
51396   arg1 = (Dali::Vector< int > *)jarg1;
51397   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51398   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51399   arg3 = &temp3;
51400   {
51401     try {
51402       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51403     } catch (std::out_of_range& e) {
51404       {
51405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51406       };
51407     } catch (std::exception& e) {
51408       {
51409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51410       };
51411     } catch (Dali::DaliException e) {
51412       {
51413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51414       };
51415     } catch (...) {
51416       {
51417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51418       };
51419     }
51420   }
51421
51422 }
51423
51424
51425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51426   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51427   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51428   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51429   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51430
51431   arg1 = (Dali::Vector< int > *)jarg1;
51432   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51433   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51434   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51435   {
51436     try {
51437       (arg1)->Insert(arg2,arg3,arg4);
51438     } catch (std::out_of_range& e) {
51439       {
51440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51441       };
51442     } catch (std::exception& e) {
51443       {
51444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51445       };
51446     } catch (Dali::DaliException e) {
51447       {
51448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51449       };
51450     } catch (...) {
51451       {
51452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51453       };
51454     }
51455   }
51456
51457 }
51458
51459
51460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51461   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51462   Dali::Vector< int >::SizeType arg2 ;
51463
51464   arg1 = (Dali::Vector< int > *)jarg1;
51465   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51466   {
51467     try {
51468       (arg1)->Reserve(arg2);
51469     } catch (std::out_of_range& e) {
51470       {
51471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51472       };
51473     } catch (std::exception& e) {
51474       {
51475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51476       };
51477     } catch (Dali::DaliException e) {
51478       {
51479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51480       };
51481     } catch (...) {
51482       {
51483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51484       };
51485     }
51486   }
51487
51488 }
51489
51490
51491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51492   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51493   Dali::Vector< int >::SizeType arg2 ;
51494
51495   arg1 = (Dali::Vector< int > *)jarg1;
51496   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51497   {
51498     try {
51499       (arg1)->Resize(arg2);
51500     } catch (std::out_of_range& e) {
51501       {
51502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51503       };
51504     } catch (std::exception& e) {
51505       {
51506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51507       };
51508     } catch (Dali::DaliException e) {
51509       {
51510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51511       };
51512     } catch (...) {
51513       {
51514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51515       };
51516     }
51517   }
51518
51519 }
51520
51521
51522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51523   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51524   Dali::Vector< int >::SizeType arg2 ;
51525   Dali::Vector< int >::ItemType *arg3 = 0 ;
51526   Dali::Vector< int >::ItemType temp3 ;
51527
51528   arg1 = (Dali::Vector< int > *)jarg1;
51529   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51530   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51531   arg3 = &temp3;
51532   {
51533     try {
51534       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51535     } catch (std::out_of_range& e) {
51536       {
51537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51538       };
51539     } catch (std::exception& e) {
51540       {
51541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51542       };
51543     } catch (Dali::DaliException e) {
51544       {
51545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51546       };
51547     } catch (...) {
51548       {
51549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51550       };
51551     }
51552   }
51553
51554 }
51555
51556
51557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51558   void * jresult ;
51559   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51560   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51561   Dali::Vector< int >::Iterator result;
51562
51563   arg1 = (Dali::Vector< int > *)jarg1;
51564   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51565   {
51566     try {
51567       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51568     } catch (std::out_of_range& e) {
51569       {
51570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51571       };
51572     } catch (std::exception& e) {
51573       {
51574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51575       };
51576     } catch (Dali::DaliException e) {
51577       {
51578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51579       };
51580     } catch (...) {
51581       {
51582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51583       };
51584     }
51585   }
51586
51587   jresult = (void *)result;
51588   return jresult;
51589 }
51590
51591
51592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51593   void * jresult ;
51594   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51595   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51596   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51597   Dali::Vector< int >::Iterator result;
51598
51599   arg1 = (Dali::Vector< int > *)jarg1;
51600   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51601   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51602   {
51603     try {
51604       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51605     } catch (std::out_of_range& e) {
51606       {
51607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51608       };
51609     } catch (std::exception& e) {
51610       {
51611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51612       };
51613     } catch (Dali::DaliException e) {
51614       {
51615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51616       };
51617     } catch (...) {
51618       {
51619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51620       };
51621     }
51622   }
51623
51624   jresult = (void *)result;
51625   return jresult;
51626 }
51627
51628
51629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51630   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51631   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51632
51633   arg1 = (Dali::Vector< int > *)jarg1;
51634   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51635   {
51636     try {
51637       (arg1)->Remove(arg2);
51638     } catch (std::out_of_range& e) {
51639       {
51640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51641       };
51642     } catch (std::exception& e) {
51643       {
51644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51645       };
51646     } catch (Dali::DaliException e) {
51647       {
51648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51649       };
51650     } catch (...) {
51651       {
51652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51653       };
51654     }
51655   }
51656
51657 }
51658
51659
51660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51661   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51662   Dali::Vector< int > *arg2 = 0 ;
51663
51664   arg1 = (Dali::Vector< int > *)jarg1;
51665   arg2 = (Dali::Vector< int > *)jarg2;
51666   if (!arg2) {
51667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51668     return ;
51669   }
51670   {
51671     try {
51672       (arg1)->Swap(*arg2);
51673     } catch (std::out_of_range& e) {
51674       {
51675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51676       };
51677     } catch (std::exception& e) {
51678       {
51679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51680       };
51681     } catch (Dali::DaliException e) {
51682       {
51683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51684       };
51685     } catch (...) {
51686       {
51687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51688       };
51689     }
51690   }
51691
51692 }
51693
51694
51695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51696   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51697
51698   arg1 = (Dali::Vector< int > *)jarg1;
51699   {
51700     try {
51701       (arg1)->Clear();
51702     } catch (std::out_of_range& e) {
51703       {
51704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51705       };
51706     } catch (std::exception& e) {
51707       {
51708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51709       };
51710     } catch (Dali::DaliException e) {
51711       {
51712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51713       };
51714     } catch (...) {
51715       {
51716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51717       };
51718     }
51719   }
51720
51721 }
51722
51723
51724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51725   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51726
51727   arg1 = (Dali::Vector< int > *)jarg1;
51728   {
51729     try {
51730       (arg1)->Release();
51731     } catch (std::out_of_range& e) {
51732       {
51733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51734       };
51735     } catch (std::exception& e) {
51736       {
51737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51738       };
51739     } catch (Dali::DaliException e) {
51740       {
51741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51742       };
51743     } catch (...) {
51744       {
51745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51746       };
51747     }
51748   }
51749
51750 }
51751
51752
51753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51754   int jresult ;
51755   int result;
51756
51757   result = (int)Dali::Vector< float >::BaseType;
51758   jresult = (int)result;
51759   return jresult;
51760 }
51761
51762
51763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51764   void * jresult ;
51765   Dali::Vector< float > *result = 0 ;
51766
51767   {
51768     try {
51769       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51770     } catch (std::out_of_range& e) {
51771       {
51772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51773       };
51774     } catch (std::exception& e) {
51775       {
51776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51777       };
51778     } catch (Dali::DaliException e) {
51779       {
51780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51781       };
51782     } catch (...) {
51783       {
51784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51785       };
51786     }
51787   }
51788
51789   jresult = (void *)result;
51790   return jresult;
51791 }
51792
51793
51794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51795   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51796
51797   arg1 = (Dali::Vector< float > *)jarg1;
51798   {
51799     try {
51800       delete arg1;
51801     } catch (std::out_of_range& e) {
51802       {
51803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51804       };
51805     } catch (std::exception& e) {
51806       {
51807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51808       };
51809     } catch (Dali::DaliException e) {
51810       {
51811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51812       };
51813     } catch (...) {
51814       {
51815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51816       };
51817     }
51818   }
51819
51820 }
51821
51822
51823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51824   void * jresult ;
51825   Dali::Vector< float > *arg1 = 0 ;
51826   Dali::Vector< float > *result = 0 ;
51827
51828   arg1 = (Dali::Vector< float > *)jarg1;
51829   if (!arg1) {
51830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51831     return 0;
51832   }
51833   {
51834     try {
51835       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51836     } catch (std::out_of_range& e) {
51837       {
51838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51839       };
51840     } catch (std::exception& e) {
51841       {
51842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51843       };
51844     } catch (Dali::DaliException e) {
51845       {
51846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51847       };
51848     } catch (...) {
51849       {
51850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51851       };
51852     }
51853   }
51854
51855   jresult = (void *)result;
51856   return jresult;
51857 }
51858
51859
51860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51861   void * jresult ;
51862   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51863   Dali::Vector< float > *arg2 = 0 ;
51864   Dali::Vector< float > *result = 0 ;
51865
51866   arg1 = (Dali::Vector< float > *)jarg1;
51867   arg2 = (Dali::Vector< float > *)jarg2;
51868   if (!arg2) {
51869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51870     return 0;
51871   }
51872   {
51873     try {
51874       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51875     } catch (std::out_of_range& e) {
51876       {
51877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51878       };
51879     } catch (std::exception& e) {
51880       {
51881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51882       };
51883     } catch (Dali::DaliException e) {
51884       {
51885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51886       };
51887     } catch (...) {
51888       {
51889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51890       };
51891     }
51892   }
51893
51894   jresult = (void *)result;
51895   return jresult;
51896 }
51897
51898
51899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51900   void * jresult ;
51901   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51902   Dali::Vector< float >::Iterator result;
51903
51904   arg1 = (Dali::Vector< float > *)jarg1;
51905   {
51906     try {
51907       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51908     } catch (std::out_of_range& e) {
51909       {
51910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51911       };
51912     } catch (std::exception& e) {
51913       {
51914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51915       };
51916     } catch (Dali::DaliException e) {
51917       {
51918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51919       };
51920     } catch (...) {
51921       {
51922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51923       };
51924     }
51925   }
51926
51927   jresult = (void *)result;
51928   return jresult;
51929 }
51930
51931
51932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51933   void * jresult ;
51934   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51935   Dali::Vector< float >::Iterator result;
51936
51937   arg1 = (Dali::Vector< float > *)jarg1;
51938   {
51939     try {
51940       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51941     } catch (std::out_of_range& e) {
51942       {
51943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51944       };
51945     } catch (std::exception& e) {
51946       {
51947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51948       };
51949     } catch (Dali::DaliException e) {
51950       {
51951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51952       };
51953     } catch (...) {
51954       {
51955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51956       };
51957     }
51958   }
51959
51960   jresult = (void *)result;
51961   return jresult;
51962 }
51963
51964
51965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51966   void * jresult ;
51967   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51968   Dali::Vector< float >::SizeType arg2 ;
51969   Dali::Vector< float >::ItemType *result = 0 ;
51970
51971   arg1 = (Dali::Vector< float > *)jarg1;
51972   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51973   {
51974     try {
51975       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51976     } catch (std::out_of_range& e) {
51977       {
51978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51979       };
51980     } catch (std::exception& e) {
51981       {
51982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51983       };
51984     } catch (Dali::DaliException e) {
51985       {
51986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51987       };
51988     } catch (...) {
51989       {
51990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51991       };
51992     }
51993   }
51994
51995   jresult = (void *)result;
51996   return jresult;
51997 }
51998
51999
52000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
52001   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52002   Dali::Vector< float >::ItemType *arg2 = 0 ;
52003   Dali::Vector< float >::ItemType temp2 ;
52004
52005   arg1 = (Dali::Vector< float > *)jarg1;
52006   temp2 = (Dali::Vector< float >::ItemType)jarg2;
52007   arg2 = &temp2;
52008   {
52009     try {
52010       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
52011     } catch (std::out_of_range& e) {
52012       {
52013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52014       };
52015     } catch (std::exception& e) {
52016       {
52017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52018       };
52019     } catch (Dali::DaliException e) {
52020       {
52021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52022       };
52023     } catch (...) {
52024       {
52025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52026       };
52027     }
52028   }
52029
52030 }
52031
52032
52033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
52034   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52035   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52036   Dali::Vector< float >::ItemType *arg3 = 0 ;
52037   Dali::Vector< float >::ItemType temp3 ;
52038
52039   arg1 = (Dali::Vector< float > *)jarg1;
52040   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52041   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52042   arg3 = &temp3;
52043   {
52044     try {
52045       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52046     } catch (std::out_of_range& e) {
52047       {
52048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52049       };
52050     } catch (std::exception& e) {
52051       {
52052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52053       };
52054     } catch (Dali::DaliException e) {
52055       {
52056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52057       };
52058     } catch (...) {
52059       {
52060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52061       };
52062     }
52063   }
52064
52065 }
52066
52067
52068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52069   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52070   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52071   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52072   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
52073
52074   arg1 = (Dali::Vector< float > *)jarg1;
52075   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52076   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52077   arg4 = (Dali::Vector< float >::Iterator)jarg4;
52078   {
52079     try {
52080       (arg1)->Insert(arg2,arg3,arg4);
52081     } catch (std::out_of_range& e) {
52082       {
52083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52084       };
52085     } catch (std::exception& e) {
52086       {
52087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52088       };
52089     } catch (Dali::DaliException e) {
52090       {
52091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52092       };
52093     } catch (...) {
52094       {
52095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52096       };
52097     }
52098   }
52099
52100 }
52101
52102
52103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52104   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52105   Dali::Vector< float >::SizeType arg2 ;
52106
52107   arg1 = (Dali::Vector< float > *)jarg1;
52108   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52109   {
52110     try {
52111       (arg1)->Reserve(arg2);
52112     } catch (std::out_of_range& e) {
52113       {
52114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52115       };
52116     } catch (std::exception& e) {
52117       {
52118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52119       };
52120     } catch (Dali::DaliException e) {
52121       {
52122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52123       };
52124     } catch (...) {
52125       {
52126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52127       };
52128     }
52129   }
52130
52131 }
52132
52133 //// ========================= end of part 2 =============================
52134
52135 //// ========================== start part 3 ===============================
52136
52137
52138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52139   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52140   Dali::Vector< float >::SizeType arg2 ;
52141
52142   arg1 = (Dali::Vector< float > *)jarg1;
52143   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52144   {
52145     try {
52146       (arg1)->Resize(arg2);
52147     } catch (std::out_of_range& e) {
52148       {
52149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52150       };
52151     } catch (std::exception& e) {
52152       {
52153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52154       };
52155     } catch (Dali::DaliException e) {
52156       {
52157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52158       };
52159     } catch (...) {
52160       {
52161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52162       };
52163     }
52164   }
52165
52166 }
52167
52168
52169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52170   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52171   Dali::Vector< float >::SizeType arg2 ;
52172   Dali::Vector< float >::ItemType *arg3 = 0 ;
52173   Dali::Vector< float >::ItemType temp3 ;
52174
52175   arg1 = (Dali::Vector< float > *)jarg1;
52176   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52177   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52178   arg3 = &temp3;
52179   {
52180     try {
52181       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52182     } catch (std::out_of_range& e) {
52183       {
52184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52185       };
52186     } catch (std::exception& e) {
52187       {
52188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52189       };
52190     } catch (Dali::DaliException e) {
52191       {
52192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52193       };
52194     } catch (...) {
52195       {
52196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52197       };
52198     }
52199   }
52200
52201 }
52202
52203
52204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52205   void * jresult ;
52206   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52207   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52208   Dali::Vector< float >::Iterator result;
52209
52210   arg1 = (Dali::Vector< float > *)jarg1;
52211   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52212   {
52213     try {
52214       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52215     } catch (std::out_of_range& e) {
52216       {
52217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52218       };
52219     } catch (std::exception& e) {
52220       {
52221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52222       };
52223     } catch (Dali::DaliException e) {
52224       {
52225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52226       };
52227     } catch (...) {
52228       {
52229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52230       };
52231     }
52232   }
52233
52234   jresult = (void *)result;
52235   return jresult;
52236 }
52237
52238
52239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52240   void * jresult ;
52241   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52242   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52243   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52244   Dali::Vector< float >::Iterator result;
52245
52246   arg1 = (Dali::Vector< float > *)jarg1;
52247   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52248   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52249   {
52250     try {
52251       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52252     } catch (std::out_of_range& e) {
52253       {
52254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52255       };
52256     } catch (std::exception& e) {
52257       {
52258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52259       };
52260     } catch (Dali::DaliException e) {
52261       {
52262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52263       };
52264     } catch (...) {
52265       {
52266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52267       };
52268     }
52269   }
52270
52271   jresult = (void *)result;
52272   return jresult;
52273 }
52274
52275
52276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52277   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52278   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52279
52280   arg1 = (Dali::Vector< float > *)jarg1;
52281   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52282   {
52283     try {
52284       (arg1)->Remove(arg2);
52285     } catch (std::out_of_range& e) {
52286       {
52287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52288       };
52289     } catch (std::exception& e) {
52290       {
52291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52292       };
52293     } catch (Dali::DaliException e) {
52294       {
52295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52296       };
52297     } catch (...) {
52298       {
52299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52300       };
52301     }
52302   }
52303
52304 }
52305
52306
52307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52308   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52309   Dali::Vector< float > *arg2 = 0 ;
52310
52311   arg1 = (Dali::Vector< float > *)jarg1;
52312   arg2 = (Dali::Vector< float > *)jarg2;
52313   if (!arg2) {
52314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52315     return ;
52316   }
52317   {
52318     try {
52319       (arg1)->Swap(*arg2);
52320     } catch (std::out_of_range& e) {
52321       {
52322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52323       };
52324     } catch (std::exception& e) {
52325       {
52326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52327       };
52328     } catch (Dali::DaliException e) {
52329       {
52330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52331       };
52332     } catch (...) {
52333       {
52334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52335       };
52336     }
52337   }
52338
52339 }
52340
52341
52342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52343   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52344
52345   arg1 = (Dali::Vector< float > *)jarg1;
52346   {
52347     try {
52348       (arg1)->Clear();
52349     } catch (std::out_of_range& e) {
52350       {
52351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52352       };
52353     } catch (std::exception& e) {
52354       {
52355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52356       };
52357     } catch (Dali::DaliException e) {
52358       {
52359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52360       };
52361     } catch (...) {
52362       {
52363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52364       };
52365     }
52366   }
52367
52368 }
52369
52370
52371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52372   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52373
52374   arg1 = (Dali::Vector< float > *)jarg1;
52375   {
52376     try {
52377       (arg1)->Release();
52378     } catch (std::out_of_range& e) {
52379       {
52380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52381       };
52382     } catch (std::exception& e) {
52383       {
52384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52385       };
52386     } catch (Dali::DaliException e) {
52387       {
52388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52389       };
52390     } catch (...) {
52391       {
52392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52393       };
52394     }
52395   }
52396
52397 }
52398
52399
52400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52401   int jresult ;
52402   int result;
52403
52404   result = (int)Dali::Vector< unsigned char >::BaseType;
52405   jresult = (int)result;
52406   return jresult;
52407 }
52408
52409
52410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52411   void * jresult ;
52412   Dali::Vector< unsigned char > *result = 0 ;
52413
52414   {
52415     try {
52416       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52417     } catch (std::out_of_range& e) {
52418       {
52419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52420       };
52421     } catch (std::exception& e) {
52422       {
52423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52424       };
52425     } catch (Dali::DaliException e) {
52426       {
52427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52428       };
52429     } catch (...) {
52430       {
52431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52432       };
52433     }
52434   }
52435
52436   jresult = (void *)result;
52437   return jresult;
52438 }
52439
52440
52441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52442   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52443
52444   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52445   {
52446     try {
52447       delete arg1;
52448     } catch (std::out_of_range& e) {
52449       {
52450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52451       };
52452     } catch (std::exception& e) {
52453       {
52454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52455       };
52456     } catch (Dali::DaliException e) {
52457       {
52458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52459       };
52460     } catch (...) {
52461       {
52462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52463       };
52464     }
52465   }
52466
52467 }
52468
52469
52470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52471   void * jresult ;
52472   Dali::Vector< unsigned char > *arg1 = 0 ;
52473   Dali::Vector< unsigned char > *result = 0 ;
52474
52475   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52476   if (!arg1) {
52477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52478     return 0;
52479   }
52480   {
52481     try {
52482       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52483     } catch (std::out_of_range& e) {
52484       {
52485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52486       };
52487     } catch (std::exception& e) {
52488       {
52489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52490       };
52491     } catch (Dali::DaliException e) {
52492       {
52493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52494       };
52495     } catch (...) {
52496       {
52497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52498       };
52499     }
52500   }
52501
52502   jresult = (void *)result;
52503   return jresult;
52504 }
52505
52506
52507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52508   void * jresult ;
52509   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52510   Dali::Vector< unsigned char > *arg2 = 0 ;
52511   Dali::Vector< unsigned char > *result = 0 ;
52512
52513   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52514   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52515   if (!arg2) {
52516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52517     return 0;
52518   }
52519   {
52520     try {
52521       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52522     } catch (std::out_of_range& e) {
52523       {
52524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52525       };
52526     } catch (std::exception& e) {
52527       {
52528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52529       };
52530     } catch (Dali::DaliException e) {
52531       {
52532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52533       };
52534     } catch (...) {
52535       {
52536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52537       };
52538     }
52539   }
52540
52541   jresult = (void *)result;
52542   return jresult;
52543 }
52544
52545
52546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52547   void * jresult ;
52548   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52549   Dali::Vector< unsigned char >::Iterator result;
52550
52551   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52552   {
52553     try {
52554       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52555     } catch (std::out_of_range& e) {
52556       {
52557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52558       };
52559     } catch (std::exception& e) {
52560       {
52561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52562       };
52563     } catch (Dali::DaliException e) {
52564       {
52565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52566       };
52567     } catch (...) {
52568       {
52569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52570       };
52571     }
52572   }
52573
52574   jresult = (void *)result;
52575   return jresult;
52576 }
52577
52578
52579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52580   void * jresult ;
52581   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52582   Dali::Vector< unsigned char >::Iterator result;
52583
52584   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52585   {
52586     try {
52587       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52588     } catch (std::out_of_range& e) {
52589       {
52590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52591       };
52592     } catch (std::exception& e) {
52593       {
52594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52595       };
52596     } catch (Dali::DaliException e) {
52597       {
52598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52599       };
52600     } catch (...) {
52601       {
52602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52603       };
52604     }
52605   }
52606
52607   jresult = (void *)result;
52608   return jresult;
52609 }
52610
52611
52612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52613   void * jresult ;
52614   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52615   Dali::Vector< unsigned char >::SizeType arg2 ;
52616   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52617
52618   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52619   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52620   {
52621     try {
52622       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52623     } catch (std::out_of_range& e) {
52624       {
52625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52626       };
52627     } catch (std::exception& e) {
52628       {
52629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52630       };
52631     } catch (Dali::DaliException e) {
52632       {
52633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52634       };
52635     } catch (...) {
52636       {
52637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52638       };
52639     }
52640   }
52641
52642   jresult = (void *)result;
52643   return jresult;
52644 }
52645
52646
52647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52648   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52649   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52650   Dali::Vector< unsigned char >::ItemType temp2 ;
52651
52652   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52653   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52654   arg2 = &temp2;
52655   {
52656     try {
52657       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52658     } catch (std::out_of_range& e) {
52659       {
52660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52661       };
52662     } catch (std::exception& e) {
52663       {
52664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52665       };
52666     } catch (Dali::DaliException e) {
52667       {
52668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52669       };
52670     } catch (...) {
52671       {
52672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52673       };
52674     }
52675   }
52676
52677 }
52678
52679
52680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52681   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52682   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52683   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52684   Dali::Vector< unsigned char >::ItemType temp3 ;
52685
52686   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52687   arg2 = jarg2;
52688   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52689   arg3 = &temp3;
52690   {
52691     try {
52692       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52693     } catch (std::out_of_range& e) {
52694       {
52695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52696       };
52697     } catch (std::exception& e) {
52698       {
52699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52700       };
52701     } catch (Dali::DaliException e) {
52702       {
52703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52704       };
52705     } catch (...) {
52706       {
52707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52708       };
52709     }
52710   }
52711
52712
52713
52714 }
52715
52716
52717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52718   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52719   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52720   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52721   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52722
52723   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52724   arg2 = jarg2;
52725   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52726   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52727   {
52728     try {
52729       (arg1)->Insert(arg2,arg3,arg4);
52730     } catch (std::out_of_range& e) {
52731       {
52732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52733       };
52734     } catch (std::exception& e) {
52735       {
52736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52737       };
52738     } catch (Dali::DaliException e) {
52739       {
52740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52741       };
52742     } catch (...) {
52743       {
52744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52745       };
52746     }
52747   }
52748
52749
52750
52751 }
52752
52753
52754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52755   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52756   Dali::Vector< unsigned char >::SizeType arg2 ;
52757
52758   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52759   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52760   {
52761     try {
52762       (arg1)->Reserve(arg2);
52763     } catch (std::out_of_range& e) {
52764       {
52765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52766       };
52767     } catch (std::exception& e) {
52768       {
52769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52770       };
52771     } catch (Dali::DaliException e) {
52772       {
52773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52774       };
52775     } catch (...) {
52776       {
52777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52778       };
52779     }
52780   }
52781
52782 }
52783
52784
52785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52786   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52787   Dali::Vector< unsigned char >::SizeType arg2 ;
52788
52789   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52790   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52791   {
52792     try {
52793       (arg1)->Resize(arg2);
52794     } catch (std::out_of_range& e) {
52795       {
52796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52797       };
52798     } catch (std::exception& e) {
52799       {
52800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52801       };
52802     } catch (Dali::DaliException e) {
52803       {
52804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52805       };
52806     } catch (...) {
52807       {
52808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52809       };
52810     }
52811   }
52812
52813 }
52814
52815
52816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52817   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52818   Dali::Vector< unsigned char >::SizeType arg2 ;
52819   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52820   Dali::Vector< unsigned char >::ItemType temp3 ;
52821
52822   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52823   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52824   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52825   arg3 = &temp3;
52826   {
52827     try {
52828       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52829     } catch (std::out_of_range& e) {
52830       {
52831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52832       };
52833     } catch (std::exception& e) {
52834       {
52835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52836       };
52837     } catch (Dali::DaliException e) {
52838       {
52839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52840       };
52841     } catch (...) {
52842       {
52843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52844       };
52845     }
52846   }
52847
52848 }
52849
52850
52851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52852   void * jresult ;
52853   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52854   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52855   Dali::Vector< unsigned char >::Iterator result;
52856
52857   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52858   arg2 = jarg2;
52859   {
52860     try {
52861       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52862     } catch (std::out_of_range& e) {
52863       {
52864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52865       };
52866     } catch (std::exception& e) {
52867       {
52868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52869       };
52870     } catch (Dali::DaliException e) {
52871       {
52872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52873       };
52874     } catch (...) {
52875       {
52876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52877       };
52878     }
52879   }
52880
52881   jresult = (void *)result;
52882
52883
52884   return jresult;
52885 }
52886
52887
52888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52889   void * jresult ;
52890   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52891   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52892   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52893   Dali::Vector< unsigned char >::Iterator result;
52894
52895   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52896   arg2 = jarg2;
52897   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52898   {
52899     try {
52900       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52901     } catch (std::out_of_range& e) {
52902       {
52903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52904       };
52905     } catch (std::exception& e) {
52906       {
52907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52908       };
52909     } catch (Dali::DaliException e) {
52910       {
52911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52912       };
52913     } catch (...) {
52914       {
52915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52916       };
52917     }
52918   }
52919
52920   jresult = (void *)result;
52921
52922
52923   return jresult;
52924 }
52925
52926
52927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52928   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52929   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52930
52931   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52932   arg2 = jarg2;
52933   {
52934     try {
52935       (arg1)->Remove(arg2);
52936     } catch (std::out_of_range& e) {
52937       {
52938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52939       };
52940     } catch (std::exception& e) {
52941       {
52942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52943       };
52944     } catch (Dali::DaliException e) {
52945       {
52946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52947       };
52948     } catch (...) {
52949       {
52950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52951       };
52952     }
52953   }
52954
52955
52956
52957 }
52958
52959
52960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52961   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52962   Dali::Vector< unsigned char > *arg2 = 0 ;
52963
52964   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52965   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52966   if (!arg2) {
52967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52968     return ;
52969   }
52970   {
52971     try {
52972       (arg1)->Swap(*arg2);
52973     } catch (std::out_of_range& e) {
52974       {
52975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52976       };
52977     } catch (std::exception& e) {
52978       {
52979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52980       };
52981     } catch (Dali::DaliException e) {
52982       {
52983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52984       };
52985     } catch (...) {
52986       {
52987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52988       };
52989     }
52990   }
52991
52992 }
52993
52994
52995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52996   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52997
52998   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52999   {
53000     try {
53001       (arg1)->Clear();
53002     } catch (std::out_of_range& e) {
53003       {
53004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53005       };
53006     } catch (std::exception& e) {
53007       {
53008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53009       };
53010     } catch (Dali::DaliException e) {
53011       {
53012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53013       };
53014     } catch (...) {
53015       {
53016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53017       };
53018     }
53019   }
53020
53021 }
53022
53023
53024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
53025   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53026
53027   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53028   {
53029     try {
53030       (arg1)->Release();
53031     } catch (std::out_of_range& e) {
53032       {
53033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53034       };
53035     } catch (std::exception& e) {
53036       {
53037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53038       };
53039     } catch (Dali::DaliException e) {
53040       {
53041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53042       };
53043     } catch (...) {
53044       {
53045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53046       };
53047     }
53048   }
53049
53050 }
53051
53052
53053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
53054   int jresult ;
53055   int result;
53056
53057   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
53058   jresult = (int)result;
53059   return jresult;
53060 }
53061
53062
53063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
53064   void * jresult ;
53065   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53066
53067   {
53068     try {
53069       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
53070     } catch (std::out_of_range& e) {
53071       {
53072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53073       };
53074     } catch (std::exception& e) {
53075       {
53076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53077       };
53078     } catch (Dali::DaliException e) {
53079       {
53080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53081       };
53082     } catch (...) {
53083       {
53084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53085       };
53086     }
53087   }
53088
53089   jresult = (void *)result;
53090   return jresult;
53091 }
53092
53093
53094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53095   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53096
53097   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53098   {
53099     try {
53100       delete arg1;
53101     } catch (std::out_of_range& e) {
53102       {
53103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53104       };
53105     } catch (std::exception& e) {
53106       {
53107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53108       };
53109     } catch (Dali::DaliException e) {
53110       {
53111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53112       };
53113     } catch (...) {
53114       {
53115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53116       };
53117     }
53118   }
53119
53120 }
53121
53122
53123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53124   void * jresult ;
53125   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53126   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53127
53128   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53129   if (!arg1) {
53130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53131     return 0;
53132   }
53133   {
53134     try {
53135       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53136     } catch (std::out_of_range& e) {
53137       {
53138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53139       };
53140     } catch (std::exception& e) {
53141       {
53142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53143       };
53144     } catch (Dali::DaliException e) {
53145       {
53146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53147       };
53148     } catch (...) {
53149       {
53150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53151       };
53152     }
53153   }
53154
53155   jresult = (void *)result;
53156   return jresult;
53157 }
53158
53159
53160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53161   void * jresult ;
53162   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53163   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53164   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53165
53166   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53167   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53168   if (!arg2) {
53169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53170     return 0;
53171   }
53172   {
53173     try {
53174       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53175     } catch (std::out_of_range& e) {
53176       {
53177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53178       };
53179     } catch (std::exception& e) {
53180       {
53181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53182       };
53183     } catch (Dali::DaliException e) {
53184       {
53185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53186       };
53187     } catch (...) {
53188       {
53189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53190       };
53191     }
53192   }
53193
53194   jresult = (void *)result;
53195   return jresult;
53196 }
53197
53198
53199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53200   void * jresult ;
53201   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53202   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53203
53204   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53205   {
53206     try {
53207       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53208     } catch (std::out_of_range& e) {
53209       {
53210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53211       };
53212     } catch (std::exception& e) {
53213       {
53214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53215       };
53216     } catch (Dali::DaliException e) {
53217       {
53218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53219       };
53220     } catch (...) {
53221       {
53222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53223       };
53224     }
53225   }
53226
53227   jresult = (void *)result;
53228   return jresult;
53229 }
53230
53231
53232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53233   void * jresult ;
53234   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53235   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53236
53237   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53238   {
53239     try {
53240       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53241     } catch (std::out_of_range& e) {
53242       {
53243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53244       };
53245     } catch (std::exception& e) {
53246       {
53247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53248       };
53249     } catch (Dali::DaliException e) {
53250       {
53251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53252       };
53253     } catch (...) {
53254       {
53255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53256       };
53257     }
53258   }
53259
53260   jresult = (void *)result;
53261   return jresult;
53262 }
53263
53264
53265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53266   void * jresult ;
53267   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53268   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53269   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53270
53271   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53272   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53273   {
53274     try {
53275       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53276     } catch (std::out_of_range& e) {
53277       {
53278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53279       };
53280     } catch (std::exception& e) {
53281       {
53282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53283       };
53284     } catch (Dali::DaliException e) {
53285       {
53286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53287       };
53288     } catch (...) {
53289       {
53290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53291       };
53292     }
53293   }
53294
53295   jresult = (void *)result;
53296   return jresult;
53297 }
53298
53299
53300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53301   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53302   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53303
53304   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53305   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53306   if (!arg2) {
53307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53308     return ;
53309   }
53310   {
53311     try {
53312       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53313     } catch (std::out_of_range& e) {
53314       {
53315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53316       };
53317     } catch (std::exception& e) {
53318       {
53319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53320       };
53321     } catch (Dali::DaliException e) {
53322       {
53323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53324       };
53325     } catch (...) {
53326       {
53327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53328       };
53329     }
53330   }
53331
53332 }
53333
53334
53335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53336   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53337   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53338   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53339
53340   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53341   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53342   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53343   if (!arg3) {
53344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53345     return ;
53346   }
53347   {
53348     try {
53349       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53350     } catch (std::out_of_range& e) {
53351       {
53352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53353       };
53354     } catch (std::exception& e) {
53355       {
53356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53357       };
53358     } catch (Dali::DaliException e) {
53359       {
53360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53361       };
53362     } catch (...) {
53363       {
53364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53365       };
53366     }
53367   }
53368
53369 }
53370
53371
53372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53373   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53374   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53375   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53376   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53377
53378   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53379   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53380   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53381   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53382   {
53383     try {
53384       (arg1)->Insert(arg2,arg3,arg4);
53385     } catch (std::out_of_range& e) {
53386       {
53387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53388       };
53389     } catch (std::exception& e) {
53390       {
53391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53392       };
53393     } catch (Dali::DaliException e) {
53394       {
53395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53396       };
53397     } catch (...) {
53398       {
53399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53400       };
53401     }
53402   }
53403
53404 }
53405
53406
53407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53408   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53409   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53410
53411   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53412   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53413   {
53414     try {
53415       (arg1)->Reserve(arg2);
53416     } catch (std::out_of_range& e) {
53417       {
53418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53419       };
53420     } catch (std::exception& e) {
53421       {
53422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53423       };
53424     } catch (Dali::DaliException e) {
53425       {
53426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53427       };
53428     } catch (...) {
53429       {
53430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53431       };
53432     }
53433   }
53434
53435 }
53436
53437
53438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53439   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53440   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53441
53442   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53443   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53444   {
53445     try {
53446       (arg1)->Resize(arg2);
53447     } catch (std::out_of_range& e) {
53448       {
53449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53450       };
53451     } catch (std::exception& e) {
53452       {
53453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53454       };
53455     } catch (Dali::DaliException e) {
53456       {
53457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53458       };
53459     } catch (...) {
53460       {
53461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53462       };
53463     }
53464   }
53465
53466 }
53467
53468
53469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53470   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53471   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53472   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53473
53474   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53475   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53476   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53477   if (!arg3) {
53478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53479     return ;
53480   }
53481   {
53482     try {
53483       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53484     } catch (std::out_of_range& e) {
53485       {
53486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53487       };
53488     } catch (std::exception& e) {
53489       {
53490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53491       };
53492     } catch (Dali::DaliException e) {
53493       {
53494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53495       };
53496     } catch (...) {
53497       {
53498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53499       };
53500     }
53501   }
53502
53503 }
53504
53505
53506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53507   void * jresult ;
53508   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53509   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53510   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53511
53512   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53513   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53514   {
53515     try {
53516       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53517     } catch (std::out_of_range& e) {
53518       {
53519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53520       };
53521     } catch (std::exception& e) {
53522       {
53523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53524       };
53525     } catch (Dali::DaliException e) {
53526       {
53527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53528       };
53529     } catch (...) {
53530       {
53531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53532       };
53533     }
53534   }
53535
53536   jresult = (void *)result;
53537   return jresult;
53538 }
53539
53540
53541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53542   void * jresult ;
53543   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53544   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53545   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53546   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53547
53548   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53549   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53550   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53551   {
53552     try {
53553       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53554     } catch (std::out_of_range& e) {
53555       {
53556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53557       };
53558     } catch (std::exception& e) {
53559       {
53560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53561       };
53562     } catch (Dali::DaliException e) {
53563       {
53564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53565       };
53566     } catch (...) {
53567       {
53568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53569       };
53570     }
53571   }
53572
53573   jresult = (void *)result;
53574   return jresult;
53575 }
53576
53577
53578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53579   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53580   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53581
53582   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53583   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53584   {
53585     try {
53586       (arg1)->Remove(arg2);
53587     } catch (std::out_of_range& e) {
53588       {
53589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53590       };
53591     } catch (std::exception& e) {
53592       {
53593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53594       };
53595     } catch (Dali::DaliException e) {
53596       {
53597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53598       };
53599     } catch (...) {
53600       {
53601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53602       };
53603     }
53604   }
53605
53606 }
53607
53608
53609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53610   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53611   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53612
53613   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53614   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53615   if (!arg2) {
53616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53617     return ;
53618   }
53619   {
53620     try {
53621       (arg1)->Swap(*arg2);
53622     } catch (std::out_of_range& e) {
53623       {
53624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53625       };
53626     } catch (std::exception& e) {
53627       {
53628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53629       };
53630     } catch (Dali::DaliException e) {
53631       {
53632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53633       };
53634     } catch (...) {
53635       {
53636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53637       };
53638     }
53639   }
53640
53641 }
53642
53643
53644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53645   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53646
53647   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53648   {
53649     try {
53650       (arg1)->Clear();
53651     } catch (std::out_of_range& e) {
53652       {
53653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53654       };
53655     } catch (std::exception& e) {
53656       {
53657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53658       };
53659     } catch (Dali::DaliException e) {
53660       {
53661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53662       };
53663     } catch (...) {
53664       {
53665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53666       };
53667     }
53668   }
53669
53670 }
53671
53672
53673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53674   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53675
53676   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53677   {
53678     try {
53679       (arg1)->Release();
53680     } catch (std::out_of_range& e) {
53681       {
53682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53683       };
53684     } catch (std::exception& e) {
53685       {
53686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53687       };
53688     } catch (Dali::DaliException e) {
53689       {
53690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53691       };
53692     } catch (...) {
53693       {
53694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53695       };
53696     }
53697   }
53698
53699 }
53700
53701
53702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53703   void * jresult ;
53704   Dali::Signal< void () > *result = 0 ;
53705
53706   {
53707     try {
53708       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53709     } catch (std::out_of_range& e) {
53710       {
53711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53712       };
53713     } catch (std::exception& e) {
53714       {
53715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53716       };
53717     } catch (Dali::DaliException e) {
53718       {
53719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53720       };
53721     } catch (...) {
53722       {
53723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53724       };
53725     }
53726   }
53727
53728   jresult = (void *)result;
53729   return jresult;
53730 }
53731
53732
53733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53734   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53735
53736   arg1 = (Dali::Signal< void () > *)jarg1;
53737   {
53738     try {
53739       delete arg1;
53740     } catch (std::out_of_range& e) {
53741       {
53742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53743       };
53744     } catch (std::exception& e) {
53745       {
53746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53747       };
53748     } catch (Dali::DaliException e) {
53749       {
53750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53751       };
53752     } catch (...) {
53753       {
53754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53755       };
53756     }
53757   }
53758
53759 }
53760
53761
53762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53763   unsigned int jresult ;
53764   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53765   bool result;
53766
53767   arg1 = (Dali::Signal< void () > *)jarg1;
53768   {
53769     try {
53770       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53771     } catch (std::out_of_range& e) {
53772       {
53773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53774       };
53775     } catch (std::exception& e) {
53776       {
53777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53778       };
53779     } catch (Dali::DaliException e) {
53780       {
53781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53782       };
53783     } catch (...) {
53784       {
53785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53786       };
53787     }
53788   }
53789
53790   jresult = result;
53791   return jresult;
53792 }
53793
53794
53795 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53796   unsigned long jresult ;
53797   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53798   std::size_t result;
53799
53800   arg1 = (Dali::Signal< void () > *)jarg1;
53801   {
53802     try {
53803       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53804     } catch (std::out_of_range& e) {
53805       {
53806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53807       };
53808     } catch (std::exception& e) {
53809       {
53810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53811       };
53812     } catch (Dali::DaliException e) {
53813       {
53814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53815       };
53816     } catch (...) {
53817       {
53818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53819       };
53820     }
53821   }
53822
53823   jresult = (unsigned long)result;
53824   return jresult;
53825 }
53826
53827
53828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53829   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53830   void (*arg2)() = (void (*)()) 0 ;
53831
53832   arg1 = (Dali::Signal< void () > *)jarg1;
53833   arg2 = (void (*)())jarg2;
53834   {
53835     try {
53836       (arg1)->Connect(arg2);
53837     } catch (std::out_of_range& e) {
53838       {
53839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53840       };
53841     } catch (std::exception& e) {
53842       {
53843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53844       };
53845     } catch (Dali::DaliException e) {
53846       {
53847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53848       };
53849     } catch (...) {
53850       {
53851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53852       };
53853     }
53854   }
53855
53856 }
53857
53858
53859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53860   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53861   void (*arg2)() = (void (*)()) 0 ;
53862
53863   arg1 = (Dali::Signal< void () > *)jarg1;
53864   arg2 = (void (*)())jarg2;
53865   {
53866     try {
53867       (arg1)->Disconnect(arg2);
53868     } catch (std::out_of_range& e) {
53869       {
53870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53871       };
53872     } catch (std::exception& e) {
53873       {
53874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53875       };
53876     } catch (Dali::DaliException e) {
53877       {
53878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53879       };
53880     } catch (...) {
53881       {
53882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53883       };
53884     }
53885   }
53886
53887 }
53888
53889
53890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53891   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53892   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53893   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53894
53895   arg1 = (Dali::Signal< void () > *)jarg1;
53896   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53897   arg3 = (Dali::FunctorDelegate *)jarg3;
53898   {
53899     try {
53900       (arg1)->Connect(arg2,arg3);
53901     } catch (std::out_of_range& e) {
53902       {
53903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53904       };
53905     } catch (std::exception& e) {
53906       {
53907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53908       };
53909     } catch (Dali::DaliException e) {
53910       {
53911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53912       };
53913     } catch (...) {
53914       {
53915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53916       };
53917     }
53918   }
53919
53920 }
53921
53922
53923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53924   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53925
53926   arg1 = (Dali::Signal< void () > *)jarg1;
53927   {
53928     try {
53929       (arg1)->Emit();
53930     } catch (std::out_of_range& e) {
53931       {
53932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53933       };
53934     } catch (std::exception& e) {
53935       {
53936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53937       };
53938     } catch (Dali::DaliException e) {
53939       {
53940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53941       };
53942     } catch (...) {
53943       {
53944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53945       };
53946     }
53947   }
53948
53949 }
53950
53951
53952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53953   unsigned int jresult ;
53954   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53955   bool result;
53956
53957   arg1 = (Dali::Signal< void (float) > *)jarg1;
53958   {
53959     try {
53960       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53961     } catch (std::out_of_range& e) {
53962       {
53963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53964       };
53965     } catch (std::exception& e) {
53966       {
53967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53968       };
53969     } catch (Dali::DaliException e) {
53970       {
53971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53972       };
53973     } catch (...) {
53974       {
53975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53976       };
53977     }
53978   }
53979
53980   jresult = result;
53981   return jresult;
53982 }
53983
53984
53985 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53986   unsigned long jresult ;
53987   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53988   std::size_t result;
53989
53990   arg1 = (Dali::Signal< void (float) > *)jarg1;
53991   {
53992     try {
53993       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53994     } catch (std::out_of_range& e) {
53995       {
53996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53997       };
53998     } catch (std::exception& e) {
53999       {
54000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54001       };
54002     } catch (Dali::DaliException e) {
54003       {
54004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54005       };
54006     } catch (...) {
54007       {
54008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54009       };
54010     }
54011   }
54012
54013   jresult = (unsigned long)result;
54014   return jresult;
54015 }
54016
54017
54018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
54019   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54020   void (*arg2)(float) = (void (*)(float)) 0 ;
54021
54022   arg1 = (Dali::Signal< void (float) > *)jarg1;
54023   arg2 = (void (*)(float))jarg2;
54024   {
54025     try {
54026       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
54027     } catch (std::out_of_range& e) {
54028       {
54029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54030       };
54031     } catch (std::exception& e) {
54032       {
54033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54034       };
54035     } catch (Dali::DaliException e) {
54036       {
54037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54038       };
54039     } catch (...) {
54040       {
54041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54042       };
54043     }
54044   }
54045
54046 }
54047
54048
54049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
54050   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54051   void (*arg2)(float) = (void (*)(float)) 0 ;
54052
54053   arg1 = (Dali::Signal< void (float) > *)jarg1;
54054   arg2 = (void (*)(float))jarg2;
54055   {
54056     try {
54057       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
54058     } catch (std::out_of_range& e) {
54059       {
54060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54061       };
54062     } catch (std::exception& e) {
54063       {
54064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54065       };
54066     } catch (Dali::DaliException e) {
54067       {
54068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54069       };
54070     } catch (...) {
54071       {
54072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54073       };
54074     }
54075   }
54076
54077 }
54078
54079
54080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
54081   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54082   float arg2 ;
54083
54084   arg1 = (Dali::Signal< void (float) > *)jarg1;
54085   arg2 = (float)jarg2;
54086   {
54087     try {
54088       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54089     } catch (std::out_of_range& e) {
54090       {
54091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54092       };
54093     } catch (std::exception& e) {
54094       {
54095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54096       };
54097     } catch (Dali::DaliException e) {
54098       {
54099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54100       };
54101     } catch (...) {
54102       {
54103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54104       };
54105     }
54106   }
54107
54108 }
54109
54110
54111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54112   void * jresult ;
54113   Dali::Signal< void (float) > *result = 0 ;
54114
54115   {
54116     try {
54117       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54118     } catch (std::out_of_range& e) {
54119       {
54120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54121       };
54122     } catch (std::exception& e) {
54123       {
54124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54125       };
54126     } catch (Dali::DaliException e) {
54127       {
54128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54129       };
54130     } catch (...) {
54131       {
54132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54133       };
54134     }
54135   }
54136
54137   jresult = (void *)result;
54138   return jresult;
54139 }
54140
54141
54142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54143   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54144
54145   arg1 = (Dali::Signal< void (float) > *)jarg1;
54146   {
54147     try {
54148       delete arg1;
54149     } catch (std::out_of_range& e) {
54150       {
54151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54152       };
54153     } catch (std::exception& e) {
54154       {
54155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54156       };
54157     } catch (Dali::DaliException e) {
54158       {
54159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54160       };
54161     } catch (...) {
54162       {
54163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54164       };
54165     }
54166   }
54167
54168 }
54169
54170
54171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54172   unsigned int jresult ;
54173   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54174   bool result;
54175
54176   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54177   {
54178     try {
54179       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54180     } catch (std::out_of_range& e) {
54181       {
54182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54183       };
54184     } catch (std::exception& e) {
54185       {
54186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54187       };
54188     } catch (Dali::DaliException e) {
54189       {
54190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54191       };
54192     } catch (...) {
54193       {
54194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54195       };
54196     }
54197   }
54198
54199   jresult = result;
54200   return jresult;
54201 }
54202
54203
54204 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54205   unsigned long jresult ;
54206   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54207   std::size_t result;
54208
54209   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54210   {
54211     try {
54212       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54213     } catch (std::out_of_range& e) {
54214       {
54215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54216       };
54217     } catch (std::exception& e) {
54218       {
54219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54220       };
54221     } catch (Dali::DaliException e) {
54222       {
54223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54224       };
54225     } catch (...) {
54226       {
54227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54228       };
54229     }
54230   }
54231
54232   jresult = (unsigned long)result;
54233   return jresult;
54234 }
54235
54236
54237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54238   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54239   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54240
54241   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54242   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54243   {
54244     try {
54245       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54246     } catch (std::out_of_range& e) {
54247       {
54248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54249       };
54250     } catch (std::exception& e) {
54251       {
54252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54253       };
54254     } catch (Dali::DaliException e) {
54255       {
54256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54257       };
54258     } catch (...) {
54259       {
54260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54261       };
54262     }
54263   }
54264
54265 }
54266
54267
54268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54269   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54270   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54271
54272   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54273   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54274   {
54275     try {
54276       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54277     } catch (std::out_of_range& e) {
54278       {
54279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54280       };
54281     } catch (std::exception& e) {
54282       {
54283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54284       };
54285     } catch (Dali::DaliException e) {
54286       {
54287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54288       };
54289     } catch (...) {
54290       {
54291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54292       };
54293     }
54294   }
54295
54296 }
54297
54298
54299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54300   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54301   Dali::BaseHandle arg2 ;
54302   Dali::BaseHandle *argp2 ;
54303
54304   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54305   argp2 = (Dali::BaseHandle *)jarg2;
54306   if (!argp2) {
54307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54308     return ;
54309   }
54310   arg2 = *argp2;
54311   {
54312     try {
54313       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54314     } catch (std::out_of_range& e) {
54315       {
54316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54317       };
54318     } catch (std::exception& e) {
54319       {
54320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54321       };
54322     } catch (Dali::DaliException e) {
54323       {
54324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54325       };
54326     } catch (...) {
54327       {
54328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54329       };
54330     }
54331   }
54332
54333 }
54334
54335
54336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54337   void * jresult ;
54338   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54339
54340   {
54341     try {
54342       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54343     } catch (std::out_of_range& e) {
54344       {
54345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54346       };
54347     } catch (std::exception& e) {
54348       {
54349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54350       };
54351     } catch (Dali::DaliException e) {
54352       {
54353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54354       };
54355     } catch (...) {
54356       {
54357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54358       };
54359     }
54360   }
54361
54362   jresult = (void *)result;
54363   return jresult;
54364 }
54365
54366
54367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54368   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54369
54370   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54371   {
54372     try {
54373       delete arg1;
54374     } catch (std::out_of_range& e) {
54375       {
54376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54377       };
54378     } catch (std::exception& e) {
54379       {
54380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54381       };
54382     } catch (Dali::DaliException e) {
54383       {
54384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54385       };
54386     } catch (...) {
54387       {
54388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54389       };
54390     }
54391   }
54392
54393 }
54394
54395
54396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54397   unsigned int jresult ;
54398   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54399   bool result;
54400
54401   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54402   {
54403     try {
54404       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54405     } catch (std::out_of_range& e) {
54406       {
54407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54408       };
54409     } catch (std::exception& e) {
54410       {
54411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54412       };
54413     } catch (Dali::DaliException e) {
54414       {
54415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54416       };
54417     } catch (...) {
54418       {
54419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54420       };
54421     }
54422   }
54423
54424   jresult = result;
54425   return jresult;
54426 }
54427
54428
54429 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54430   unsigned long jresult ;
54431   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54432   std::size_t result;
54433
54434   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54435   {
54436     try {
54437       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54438     } catch (std::out_of_range& e) {
54439       {
54440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54441       };
54442     } catch (std::exception& e) {
54443       {
54444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54445       };
54446     } catch (Dali::DaliException e) {
54447       {
54448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54449       };
54450     } catch (...) {
54451       {
54452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54453       };
54454     }
54455   }
54456
54457   jresult = (unsigned long)result;
54458   return jresult;
54459 }
54460
54461
54462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54463   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54464   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54465
54466   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54467   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54468   {
54469     try {
54470       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54471     } catch (std::out_of_range& e) {
54472       {
54473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54474       };
54475     } catch (std::exception& e) {
54476       {
54477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54478       };
54479     } catch (Dali::DaliException e) {
54480       {
54481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54482       };
54483     } catch (...) {
54484       {
54485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54486       };
54487     }
54488   }
54489
54490 }
54491
54492
54493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54494   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54495   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54496
54497   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54498   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54499   {
54500     try {
54501       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54502     } catch (std::out_of_range& e) {
54503       {
54504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54505       };
54506     } catch (std::exception& e) {
54507       {
54508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54509       };
54510     } catch (Dali::DaliException e) {
54511       {
54512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54513       };
54514     } catch (...) {
54515       {
54516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54517       };
54518     }
54519   }
54520
54521 }
54522
54523
54524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54525   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54526   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54527
54528   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54529   arg2 = (Dali::RefObject *)jarg2;
54530   {
54531     try {
54532       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54533     } catch (std::out_of_range& e) {
54534       {
54535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54536       };
54537     } catch (std::exception& e) {
54538       {
54539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54540       };
54541     } catch (Dali::DaliException e) {
54542       {
54543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54544       };
54545     } catch (...) {
54546       {
54547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54548       };
54549     }
54550   }
54551
54552 }
54553
54554
54555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54556   void * jresult ;
54557   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54558
54559   {
54560     try {
54561       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54562     } catch (std::out_of_range& e) {
54563       {
54564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54565       };
54566     } catch (std::exception& e) {
54567       {
54568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54569       };
54570     } catch (Dali::DaliException e) {
54571       {
54572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54573       };
54574     } catch (...) {
54575       {
54576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54577       };
54578     }
54579   }
54580
54581   jresult = (void *)result;
54582   return jresult;
54583 }
54584
54585
54586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54587   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54588
54589   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54590   {
54591     try {
54592       delete arg1;
54593     } catch (std::out_of_range& e) {
54594       {
54595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54596       };
54597     } catch (std::exception& e) {
54598       {
54599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54600       };
54601     } catch (Dali::DaliException e) {
54602       {
54603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54604       };
54605     } catch (...) {
54606       {
54607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54608       };
54609     }
54610   }
54611
54612 }
54613
54614
54615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54616   unsigned int jresult ;
54617   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54618   bool result;
54619
54620   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54621   {
54622     try {
54623       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54624     } catch (std::out_of_range& e) {
54625       {
54626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54627       };
54628     } catch (std::exception& e) {
54629       {
54630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54631       };
54632     } catch (Dali::DaliException e) {
54633       {
54634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54635       };
54636     } catch (...) {
54637       {
54638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54639       };
54640     }
54641   }
54642
54643   jresult = result;
54644   return jresult;
54645 }
54646
54647
54648 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54649   unsigned long jresult ;
54650   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54651   std::size_t result;
54652
54653   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54654   {
54655     try {
54656       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54657     } catch (std::out_of_range& e) {
54658       {
54659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54660       };
54661     } catch (std::exception& e) {
54662       {
54663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54664       };
54665     } catch (Dali::DaliException e) {
54666       {
54667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54668       };
54669     } catch (...) {
54670       {
54671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54672       };
54673     }
54674   }
54675
54676   jresult = (unsigned long)result;
54677   return jresult;
54678 }
54679
54680
54681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54682   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54683   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54684
54685   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54686   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54687   {
54688     try {
54689       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54690     } catch (std::out_of_range& e) {
54691       {
54692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54693       };
54694     } catch (std::exception& e) {
54695       {
54696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54697       };
54698     } catch (Dali::DaliException e) {
54699       {
54700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54701       };
54702     } catch (...) {
54703       {
54704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54705       };
54706     }
54707   }
54708
54709 }
54710
54711
54712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54713   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54714   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54715
54716   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54717   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54718   {
54719     try {
54720       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54721     } catch (std::out_of_range& e) {
54722       {
54723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54724       };
54725     } catch (std::exception& e) {
54726       {
54727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54728       };
54729     } catch (Dali::DaliException e) {
54730       {
54731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54732       };
54733     } catch (...) {
54734       {
54735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54736       };
54737     }
54738   }
54739
54740 }
54741
54742
54743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54744   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54745   Dali::PropertyNotification *arg2 = 0 ;
54746
54747   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54748   arg2 = (Dali::PropertyNotification *)jarg2;
54749   if (!arg2) {
54750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54751     return ;
54752   }
54753   {
54754     try {
54755       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54756     } catch (std::out_of_range& e) {
54757       {
54758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54759       };
54760     } catch (std::exception& e) {
54761       {
54762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54763       };
54764     } catch (Dali::DaliException e) {
54765       {
54766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54767       };
54768     } catch (...) {
54769       {
54770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54771       };
54772     }
54773   }
54774
54775 }
54776
54777
54778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54779   void * jresult ;
54780   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54781
54782   {
54783     try {
54784       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54785     } catch (std::out_of_range& e) {
54786       {
54787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54788       };
54789     } catch (std::exception& e) {
54790       {
54791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54792       };
54793     } catch (Dali::DaliException e) {
54794       {
54795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54796       };
54797     } catch (...) {
54798       {
54799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54800       };
54801     }
54802   }
54803
54804   jresult = (void *)result;
54805   return jresult;
54806 }
54807
54808
54809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54810   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54811
54812   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54813   {
54814     try {
54815       delete arg1;
54816     } catch (std::out_of_range& e) {
54817       {
54818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54819       };
54820     } catch (std::exception& e) {
54821       {
54822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54823       };
54824     } catch (Dali::DaliException e) {
54825       {
54826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54827       };
54828     } catch (...) {
54829       {
54830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54831       };
54832     }
54833   }
54834
54835 }
54836
54837
54838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54839   unsigned int jresult ;
54840   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54841   bool result;
54842
54843   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54844   {
54845     try {
54846       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54847     } catch (std::out_of_range& e) {
54848       {
54849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54850       };
54851     } catch (std::exception& e) {
54852       {
54853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54854       };
54855     } catch (Dali::DaliException e) {
54856       {
54857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54858       };
54859     } catch (...) {
54860       {
54861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54862       };
54863     }
54864   }
54865
54866   jresult = result;
54867   return jresult;
54868 }
54869
54870
54871 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54872   unsigned long jresult ;
54873   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54874   std::size_t result;
54875
54876   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54877   {
54878     try {
54879       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54880     } catch (std::out_of_range& e) {
54881       {
54882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54883       };
54884     } catch (std::exception& e) {
54885       {
54886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54887       };
54888     } catch (Dali::DaliException e) {
54889       {
54890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54891       };
54892     } catch (...) {
54893       {
54894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54895       };
54896     }
54897   }
54898
54899   jresult = (unsigned long)result;
54900   return jresult;
54901 }
54902
54903
54904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54905   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54906   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54907
54908   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54909   arg2 = (void (*)(Dali::Image))jarg2;
54910   {
54911     try {
54912       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54913     } catch (std::out_of_range& e) {
54914       {
54915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54916       };
54917     } catch (std::exception& e) {
54918       {
54919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54920       };
54921     } catch (Dali::DaliException e) {
54922       {
54923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54924       };
54925     } catch (...) {
54926       {
54927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54928       };
54929     }
54930   }
54931
54932 }
54933
54934
54935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54936   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54937   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54938
54939   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54940   arg2 = (void (*)(Dali::Image))jarg2;
54941   {
54942     try {
54943       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54944     } catch (std::out_of_range& e) {
54945       {
54946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54947       };
54948     } catch (std::exception& e) {
54949       {
54950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54951       };
54952     } catch (Dali::DaliException e) {
54953       {
54954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54955       };
54956     } catch (...) {
54957       {
54958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54959       };
54960     }
54961   }
54962
54963 }
54964
54965
54966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54967   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54968   Dali::Image arg2 ;
54969   Dali::Image *argp2 ;
54970
54971   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54972   argp2 = (Dali::Image *)jarg2;
54973   if (!argp2) {
54974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54975     return ;
54976   }
54977   arg2 = *argp2;
54978   {
54979     try {
54980       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54981     } catch (std::out_of_range& e) {
54982       {
54983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54984       };
54985     } catch (std::exception& e) {
54986       {
54987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54988       };
54989     } catch (Dali::DaliException e) {
54990       {
54991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54992       };
54993     } catch (...) {
54994       {
54995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54996       };
54997     }
54998   }
54999
55000 }
55001
55002
55003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
55004   void * jresult ;
55005   Dali::Signal< void (Dali::Image) > *result = 0 ;
55006
55007   {
55008     try {
55009       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
55010     } catch (std::out_of_range& e) {
55011       {
55012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55013       };
55014     } catch (std::exception& e) {
55015       {
55016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55017       };
55018     } catch (Dali::DaliException e) {
55019       {
55020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55021       };
55022     } catch (...) {
55023       {
55024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55025       };
55026     }
55027   }
55028
55029   jresult = (void *)result;
55030   return jresult;
55031 }
55032
55033
55034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
55035   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55036
55037   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55038   {
55039     try {
55040       delete arg1;
55041     } catch (std::out_of_range& e) {
55042       {
55043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55044       };
55045     } catch (std::exception& e) {
55046       {
55047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55048       };
55049     } catch (Dali::DaliException e) {
55050       {
55051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55052       };
55053     } catch (...) {
55054       {
55055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55056       };
55057     }
55058   }
55059
55060 }
55061
55062
55063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
55064   void * jresult ;
55065   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
55066
55067   {
55068     try {
55069       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
55070     } catch (std::out_of_range& e) {
55071       {
55072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55073       };
55074     } catch (std::exception& e) {
55075       {
55076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55077       };
55078     } catch (Dali::DaliException e) {
55079       {
55080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55081       };
55082     } catch (...) {
55083       {
55084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55085       };
55086     }
55087   }
55088
55089   jresult = (void *)result;
55090   return jresult;
55091 }
55092
55093
55094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55095   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55096
55097   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55098   {
55099     try {
55100       delete arg1;
55101     } catch (std::out_of_range& e) {
55102       {
55103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55104       };
55105     } catch (std::exception& e) {
55106       {
55107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55108       };
55109     } catch (Dali::DaliException e) {
55110       {
55111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55112       };
55113     } catch (...) {
55114       {
55115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55116       };
55117     }
55118   }
55119
55120 }
55121
55122
55123 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55124   unsigned int jresult ;
55125   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55126   bool result;
55127
55128   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55129   {
55130     try {
55131       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
55132     } catch (std::out_of_range& e) {
55133       {
55134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55135       };
55136     } catch (std::exception& e) {
55137       {
55138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55139       };
55140     } catch (Dali::DaliException e) {
55141       {
55142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55143       };
55144     } catch (...) {
55145       {
55146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55147       };
55148     }
55149   }
55150
55151   jresult = result;
55152   return jresult;
55153 }
55154
55155
55156 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55157   unsigned long jresult ;
55158   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55159   std::size_t result;
55160
55161   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55162   {
55163     try {
55164       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
55165     } catch (std::out_of_range& e) {
55166       {
55167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55168       };
55169     } catch (std::exception& e) {
55170       {
55171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55172       };
55173     } catch (Dali::DaliException e) {
55174       {
55175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55176       };
55177     } catch (...) {
55178       {
55179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55180       };
55181     }
55182   }
55183
55184   jresult = (unsigned long)result;
55185   return jresult;
55186 }
55187
55188
55189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55190   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55191   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55192
55193   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55194   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55195   {
55196     try {
55197       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55198     } catch (std::out_of_range& e) {
55199       {
55200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55201       };
55202     } catch (std::exception& e) {
55203       {
55204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55205       };
55206     } catch (Dali::DaliException e) {
55207       {
55208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55209       };
55210     } catch (...) {
55211       {
55212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55213       };
55214     }
55215   }
55216
55217 }
55218
55219
55220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55221   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55222   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55223
55224   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55225   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55226   {
55227     try {
55228       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55229     } catch (std::out_of_range& e) {
55230       {
55231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55232       };
55233     } catch (std::exception& e) {
55234       {
55235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55236       };
55237     } catch (Dali::DaliException e) {
55238       {
55239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55240       };
55241     } catch (...) {
55242       {
55243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55244       };
55245     }
55246   }
55247
55248 }
55249
55250
55251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55252   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55253   Dali::Actor arg2 ;
55254   Dali::LongPressGesture *arg3 = 0 ;
55255   Dali::Actor *argp2 ;
55256
55257   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55258   argp2 = (Dali::Actor *)jarg2;
55259   if (!argp2) {
55260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55261     return ;
55262   }
55263   arg2 = *argp2;
55264   arg3 = (Dali::LongPressGesture *)jarg3;
55265   if (!arg3) {
55266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55267     return ;
55268   }
55269   {
55270     try {
55271       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55272     } catch (std::out_of_range& e) {
55273       {
55274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55275       };
55276     } catch (std::exception& e) {
55277       {
55278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55279       };
55280     } catch (Dali::DaliException e) {
55281       {
55282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55283       };
55284     } catch (...) {
55285       {
55286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55287       };
55288     }
55289   }
55290
55291 }
55292
55293
55294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55295   void * jresult ;
55296   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55297
55298   {
55299     try {
55300       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55301     } catch (std::out_of_range& e) {
55302       {
55303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55304       };
55305     } catch (std::exception& e) {
55306       {
55307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55308       };
55309     } catch (Dali::DaliException e) {
55310       {
55311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55312       };
55313     } catch (...) {
55314       {
55315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55316       };
55317     }
55318   }
55319
55320   jresult = (void *)result;
55321   return jresult;
55322 }
55323
55324
55325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55326   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55327
55328   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55329   {
55330     try {
55331       delete arg1;
55332     } catch (std::out_of_range& e) {
55333       {
55334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55335       };
55336     } catch (std::exception& e) {
55337       {
55338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55339       };
55340     } catch (Dali::DaliException e) {
55341       {
55342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55343       };
55344     } catch (...) {
55345       {
55346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55347       };
55348     }
55349   }
55350
55351 }
55352
55353
55354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55355   unsigned int jresult ;
55356   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55357   bool result;
55358
55359   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55360   {
55361     try {
55362       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *)arg1);
55363     } catch (std::out_of_range& e) {
55364       {
55365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55366       };
55367     } catch (std::exception& e) {
55368       {
55369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55370       };
55371     } catch (Dali::DaliException e) {
55372       {
55373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55374       };
55375     } catch (...) {
55376       {
55377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55378       };
55379     }
55380   }
55381
55382   jresult = result;
55383   return jresult;
55384 }
55385
55386
55387 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55388   unsigned long jresult ;
55389   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55390   std::size_t result;
55391
55392   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55393   {
55394     try {
55395       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *)arg1);
55396     } catch (std::out_of_range& e) {
55397       {
55398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55399       };
55400     } catch (std::exception& e) {
55401       {
55402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55403       };
55404     } catch (Dali::DaliException e) {
55405       {
55406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55407       };
55408     } catch (...) {
55409       {
55410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55411       };
55412     }
55413   }
55414
55415   jresult = (unsigned long)result;
55416   return jresult;
55417 }
55418
55419
55420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55421   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55422   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55423
55424   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55425   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55426   {
55427     try {
55428       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55429     } catch (std::out_of_range& e) {
55430       {
55431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55432       };
55433     } catch (std::exception& e) {
55434       {
55435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55436       };
55437     } catch (Dali::DaliException e) {
55438       {
55439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55440       };
55441     } catch (...) {
55442       {
55443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55444       };
55445     }
55446   }
55447
55448 }
55449
55450
55451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55452   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55453   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55454
55455   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55456   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55457   {
55458     try {
55459       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55460     } catch (std::out_of_range& e) {
55461       {
55462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55463       };
55464     } catch (std::exception& e) {
55465       {
55466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55467       };
55468     } catch (Dali::DaliException e) {
55469       {
55470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55471       };
55472     } catch (...) {
55473       {
55474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55475       };
55476     }
55477   }
55478
55479 }
55480
55481
55482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55483   unsigned int jresult ;
55484   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55485   Dali::Actor arg2 ;
55486   Dali::TouchData *arg3 = 0 ;
55487   Dali::Actor *argp2 ;
55488   bool result;
55489
55490   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55491   argp2 = (Dali::Actor *)jarg2;
55492   if (!argp2) {
55493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55494     return 0;
55495   }
55496   arg2 = *argp2;
55497   arg3 = (Dali::TouchData *)jarg3;
55498   if (!arg3) {
55499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55500     return 0;
55501   }
55502   {
55503     try {
55504       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55505     } catch (std::out_of_range& e) {
55506       {
55507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55508       };
55509     } catch (std::exception& e) {
55510       {
55511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55512       };
55513     } catch (Dali::DaliException e) {
55514       {
55515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55516       };
55517     } catch (...) {
55518       {
55519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55520       };
55521     }
55522   }
55523
55524   jresult = result;
55525   return jresult;
55526 }
55527
55528
55529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55530   void * jresult ;
55531   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55532
55533   {
55534     try {
55535       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55536     } catch (std::out_of_range& e) {
55537       {
55538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55539       };
55540     } catch (std::exception& e) {
55541       {
55542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55543       };
55544     } catch (Dali::DaliException e) {
55545       {
55546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55547       };
55548     } catch (...) {
55549       {
55550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55551       };
55552     }
55553   }
55554
55555   jresult = (void *)result;
55556   return jresult;
55557 }
55558
55559
55560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55561   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55562
55563   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55564   {
55565     try {
55566       delete arg1;
55567     } catch (std::out_of_range& e) {
55568       {
55569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55570       };
55571     } catch (std::exception& e) {
55572       {
55573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55574       };
55575     } catch (Dali::DaliException e) {
55576       {
55577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55578       };
55579     } catch (...) {
55580       {
55581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55582       };
55583     }
55584   }
55585
55586 }
55587
55588
55589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55590   unsigned int jresult ;
55591   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55592   bool result;
55593
55594   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55595   {
55596     try {
55597       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *)arg1);
55598     } catch (std::out_of_range& e) {
55599       {
55600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55601       };
55602     } catch (std::exception& e) {
55603       {
55604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55605       };
55606     } catch (Dali::DaliException e) {
55607       {
55608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55609       };
55610     } catch (...) {
55611       {
55612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55613       };
55614     }
55615   }
55616
55617   jresult = result;
55618   return jresult;
55619 }
55620
55621
55622 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55623   unsigned long jresult ;
55624   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55625   std::size_t result;
55626
55627   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55628   {
55629     try {
55630       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *)arg1);
55631     } catch (std::out_of_range& e) {
55632       {
55633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55634       };
55635     } catch (std::exception& e) {
55636       {
55637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55638       };
55639     } catch (Dali::DaliException e) {
55640       {
55641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55642       };
55643     } catch (...) {
55644       {
55645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55646       };
55647     }
55648   }
55649
55650   jresult = (unsigned long)result;
55651   return jresult;
55652 }
55653
55654
55655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55656   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55657   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55658
55659   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55660   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55661   {
55662     try {
55663       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55664     } catch (std::out_of_range& e) {
55665       {
55666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55667       };
55668     } catch (std::exception& e) {
55669       {
55670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55671       };
55672     } catch (Dali::DaliException e) {
55673       {
55674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55675       };
55676     } catch (...) {
55677       {
55678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55679       };
55680     }
55681   }
55682
55683 }
55684
55685
55686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55687   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55688   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55689
55690   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55691   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55692   {
55693     try {
55694       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55695     } catch (std::out_of_range& e) {
55696       {
55697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55698       };
55699     } catch (std::exception& e) {
55700       {
55701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55702       };
55703     } catch (Dali::DaliException e) {
55704       {
55705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55706       };
55707     } catch (...) {
55708       {
55709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55710       };
55711     }
55712   }
55713
55714 }
55715
55716
55717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55718   unsigned int jresult ;
55719   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55720   Dali::Actor arg2 ;
55721   Dali::HoverEvent *arg3 = 0 ;
55722   Dali::Actor *argp2 ;
55723   bool result;
55724
55725   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55726   argp2 = (Dali::Actor *)jarg2;
55727   if (!argp2) {
55728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55729     return 0;
55730   }
55731   arg2 = *argp2;
55732   arg3 = (Dali::HoverEvent *)jarg3;
55733   if (!arg3) {
55734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55735     return 0;
55736   }
55737   {
55738     try {
55739       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55740     } catch (std::out_of_range& e) {
55741       {
55742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55743       };
55744     } catch (std::exception& e) {
55745       {
55746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55747       };
55748     } catch (Dali::DaliException e) {
55749       {
55750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55751       };
55752     } catch (...) {
55753       {
55754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55755       };
55756     }
55757   }
55758
55759   jresult = result;
55760   return jresult;
55761 }
55762
55763
55764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55765   void * jresult ;
55766   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55767
55768   {
55769     try {
55770       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55771     } catch (std::out_of_range& e) {
55772       {
55773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55774       };
55775     } catch (std::exception& e) {
55776       {
55777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55778       };
55779     } catch (Dali::DaliException e) {
55780       {
55781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55782       };
55783     } catch (...) {
55784       {
55785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55786       };
55787     }
55788   }
55789
55790   jresult = (void *)result;
55791   return jresult;
55792 }
55793
55794
55795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55796   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55797
55798   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55799   {
55800     try {
55801       delete arg1;
55802     } catch (std::out_of_range& e) {
55803       {
55804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55805       };
55806     } catch (std::exception& e) {
55807       {
55808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55809       };
55810     } catch (Dali::DaliException e) {
55811       {
55812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55813       };
55814     } catch (...) {
55815       {
55816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55817       };
55818     }
55819   }
55820
55821 }
55822
55823
55824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55825   unsigned int jresult ;
55826   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55827   bool result;
55828
55829   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55830   {
55831     try {
55832       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *)arg1);
55833     } catch (std::out_of_range& e) {
55834       {
55835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55836       };
55837     } catch (std::exception& e) {
55838       {
55839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55840       };
55841     } catch (Dali::DaliException e) {
55842       {
55843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55844       };
55845     } catch (...) {
55846       {
55847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55848       };
55849     }
55850   }
55851
55852   jresult = result;
55853   return jresult;
55854 }
55855
55856
55857 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55858   unsigned long jresult ;
55859   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55860   std::size_t result;
55861
55862   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55863   {
55864     try {
55865       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *)arg1);
55866     } catch (std::out_of_range& e) {
55867       {
55868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55869       };
55870     } catch (std::exception& e) {
55871       {
55872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55873       };
55874     } catch (Dali::DaliException e) {
55875       {
55876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55877       };
55878     } catch (...) {
55879       {
55880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55881       };
55882     }
55883   }
55884
55885   jresult = (unsigned long)result;
55886   return jresult;
55887 }
55888
55889
55890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55891   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55892   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55893
55894   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55895   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55896   {
55897     try {
55898       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55899     } catch (std::out_of_range& e) {
55900       {
55901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55902       };
55903     } catch (std::exception& e) {
55904       {
55905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55906       };
55907     } catch (Dali::DaliException e) {
55908       {
55909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55910       };
55911     } catch (...) {
55912       {
55913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55914       };
55915     }
55916   }
55917
55918 }
55919
55920
55921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55922   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55923   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55924
55925   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55926   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55927   {
55928     try {
55929       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55930     } catch (std::out_of_range& e) {
55931       {
55932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55933       };
55934     } catch (std::exception& e) {
55935       {
55936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55937       };
55938     } catch (Dali::DaliException e) {
55939       {
55940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55941       };
55942     } catch (...) {
55943       {
55944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55945       };
55946     }
55947   }
55948
55949 }
55950
55951
55952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55953   unsigned int jresult ;
55954   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55955   Dali::Actor arg2 ;
55956   Dali::WheelEvent *arg3 = 0 ;
55957   Dali::Actor *argp2 ;
55958   bool result;
55959
55960   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55961   argp2 = (Dali::Actor *)jarg2;
55962   if (!argp2) {
55963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55964     return 0;
55965   }
55966   arg2 = *argp2;
55967   arg3 = (Dali::WheelEvent *)jarg3;
55968   if (!arg3) {
55969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55970     return 0;
55971   }
55972   {
55973     try {
55974       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55975     } catch (std::out_of_range& e) {
55976       {
55977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55978       };
55979     } catch (std::exception& e) {
55980       {
55981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55982       };
55983     } catch (Dali::DaliException e) {
55984       {
55985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55986       };
55987     } catch (...) {
55988       {
55989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55990       };
55991     }
55992   }
55993
55994   jresult = result;
55995   return jresult;
55996 }
55997
55998
55999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
56000   void * jresult ;
56001   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
56002
56003   {
56004     try {
56005       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
56006     } catch (std::out_of_range& e) {
56007       {
56008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56009       };
56010     } catch (std::exception& e) {
56011       {
56012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56013       };
56014     } catch (Dali::DaliException e) {
56015       {
56016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56017       };
56018     } catch (...) {
56019       {
56020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56021       };
56022     }
56023   }
56024
56025   jresult = (void *)result;
56026   return jresult;
56027 }
56028
56029
56030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
56031   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
56032
56033   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
56034   {
56035     try {
56036       delete arg1;
56037     } catch (std::out_of_range& e) {
56038       {
56039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56040       };
56041     } catch (std::exception& e) {
56042       {
56043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56044       };
56045     } catch (Dali::DaliException e) {
56046       {
56047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56048       };
56049     } catch (...) {
56050       {
56051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56052       };
56053     }
56054   }
56055
56056 }
56057
56058
56059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
56060   unsigned int jresult ;
56061   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56062   bool result;
56063
56064   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56065   {
56066     try {
56067       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
56068     } catch (std::out_of_range& e) {
56069       {
56070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56071       };
56072     } catch (std::exception& e) {
56073       {
56074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56075       };
56076     } catch (Dali::DaliException e) {
56077       {
56078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56079       };
56080     } catch (...) {
56081       {
56082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56083       };
56084     }
56085   }
56086
56087   jresult = result;
56088   return jresult;
56089 }
56090
56091
56092 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56093   unsigned long jresult ;
56094   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56095   std::size_t result;
56096
56097   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56098   {
56099     try {
56100       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56101     } catch (std::out_of_range& e) {
56102       {
56103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56104       };
56105     } catch (std::exception& e) {
56106       {
56107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56108       };
56109     } catch (Dali::DaliException e) {
56110       {
56111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56112       };
56113     } catch (...) {
56114       {
56115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56116       };
56117     }
56118   }
56119
56120   jresult = (unsigned long)result;
56121   return jresult;
56122 }
56123
56124
56125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56126   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56127   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56128
56129   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56130   arg2 = (void (*)(Dali::Actor))jarg2;
56131   {
56132     try {
56133       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56134     } catch (std::out_of_range& e) {
56135       {
56136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56137       };
56138     } catch (std::exception& e) {
56139       {
56140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56141       };
56142     } catch (Dali::DaliException e) {
56143       {
56144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56145       };
56146     } catch (...) {
56147       {
56148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56149       };
56150     }
56151   }
56152
56153 }
56154
56155
56156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56157   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56158   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56159
56160   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56161   arg2 = (void (*)(Dali::Actor))jarg2;
56162   {
56163     try {
56164       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56165     } catch (std::out_of_range& e) {
56166       {
56167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56168       };
56169     } catch (std::exception& e) {
56170       {
56171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56172       };
56173     } catch (Dali::DaliException e) {
56174       {
56175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56176       };
56177     } catch (...) {
56178       {
56179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56180       };
56181     }
56182   }
56183
56184 }
56185
56186
56187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56188   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56189   Dali::Actor arg2 ;
56190   Dali::Actor *argp2 ;
56191
56192   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56193   argp2 = (Dali::Actor *)jarg2;
56194   if (!argp2) {
56195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56196     return ;
56197   }
56198   arg2 = *argp2;
56199   {
56200     try {
56201       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56202     } catch (std::out_of_range& e) {
56203       {
56204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56205       };
56206     } catch (std::exception& e) {
56207       {
56208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56209       };
56210     } catch (Dali::DaliException e) {
56211       {
56212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56213       };
56214     } catch (...) {
56215       {
56216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56217       };
56218     }
56219   }
56220
56221 }
56222
56223
56224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56225   void * jresult ;
56226   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56227
56228   {
56229     try {
56230       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56231     } catch (std::out_of_range& e) {
56232       {
56233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56234       };
56235     } catch (std::exception& e) {
56236       {
56237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56238       };
56239     } catch (Dali::DaliException e) {
56240       {
56241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56242       };
56243     } catch (...) {
56244       {
56245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56246       };
56247     }
56248   }
56249
56250   jresult = (void *)result;
56251   return jresult;
56252 }
56253
56254
56255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56256   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56257
56258   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56259   {
56260     try {
56261       delete arg1;
56262     } catch (std::out_of_range& e) {
56263       {
56264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56265       };
56266     } catch (std::exception& e) {
56267       {
56268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56269       };
56270     } catch (Dali::DaliException e) {
56271       {
56272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56273       };
56274     } catch (...) {
56275       {
56276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56277       };
56278     }
56279   }
56280
56281 }
56282
56283
56284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56285   unsigned int jresult ;
56286   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56287   bool result;
56288
56289   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56290   {
56291     try {
56292       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56293     } catch (std::out_of_range& e) {
56294       {
56295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56296       };
56297     } catch (std::exception& e) {
56298       {
56299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56300       };
56301     } catch (Dali::DaliException e) {
56302       {
56303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56304       };
56305     } catch (...) {
56306       {
56307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56308       };
56309     }
56310   }
56311
56312   jresult = result;
56313   return jresult;
56314 }
56315
56316
56317 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56318   unsigned long jresult ;
56319   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56320   std::size_t result;
56321
56322   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56323   {
56324     try {
56325       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56326     } catch (std::out_of_range& e) {
56327       {
56328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56329       };
56330     } catch (std::exception& e) {
56331       {
56332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56333       };
56334     } catch (Dali::DaliException e) {
56335       {
56336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56337       };
56338     } catch (...) {
56339       {
56340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56341       };
56342     }
56343   }
56344
56345   jresult = (unsigned long)result;
56346   return jresult;
56347 }
56348
56349
56350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56351   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56352   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56353
56354   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56355   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56356   {
56357     try {
56358       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56359     } catch (std::out_of_range& e) {
56360       {
56361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56362       };
56363     } catch (std::exception& e) {
56364       {
56365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56366       };
56367     } catch (Dali::DaliException e) {
56368       {
56369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56370       };
56371     } catch (...) {
56372       {
56373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56374       };
56375     }
56376   }
56377
56378 }
56379
56380
56381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56382   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56383   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56384
56385   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56386   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56387   {
56388     try {
56389       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56390     } catch (std::out_of_range& e) {
56391       {
56392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56393       };
56394     } catch (std::exception& e) {
56395       {
56396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56397       };
56398     } catch (Dali::DaliException e) {
56399       {
56400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56401       };
56402     } catch (...) {
56403       {
56404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56405       };
56406     }
56407   }
56408
56409 }
56410
56411
56412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56413   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56414   Dali::KeyEvent *arg2 = 0 ;
56415
56416   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56417   arg2 = (Dali::KeyEvent *)jarg2;
56418   if (!arg2) {
56419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56420     return ;
56421   }
56422   {
56423     try {
56424       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56425     } catch (std::out_of_range& e) {
56426       {
56427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56428       };
56429     } catch (std::exception& e) {
56430       {
56431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56432       };
56433     } catch (Dali::DaliException e) {
56434       {
56435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56436       };
56437     } catch (...) {
56438       {
56439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56440       };
56441     }
56442   }
56443
56444 }
56445
56446
56447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56448   void * jresult ;
56449   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56450
56451   {
56452     try {
56453       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56454     } catch (std::out_of_range& e) {
56455       {
56456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56457       };
56458     } catch (std::exception& e) {
56459       {
56460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56461       };
56462     } catch (Dali::DaliException e) {
56463       {
56464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56465       };
56466     } catch (...) {
56467       {
56468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56469       };
56470     }
56471   }
56472
56473   jresult = (void *)result;
56474   return jresult;
56475 }
56476
56477
56478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56479   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56480
56481   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56482   {
56483     try {
56484       delete arg1;
56485     } catch (std::out_of_range& e) {
56486       {
56487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56488       };
56489     } catch (std::exception& e) {
56490       {
56491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56492       };
56493     } catch (Dali::DaliException e) {
56494       {
56495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56496       };
56497     } catch (...) {
56498       {
56499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56500       };
56501     }
56502   }
56503
56504 }
56505
56506
56507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56508   unsigned int jresult ;
56509   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56510   bool result;
56511
56512   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56513   {
56514     try {
56515       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56516     } catch (std::out_of_range& e) {
56517       {
56518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56519       };
56520     } catch (std::exception& e) {
56521       {
56522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56523       };
56524     } catch (Dali::DaliException e) {
56525       {
56526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56527       };
56528     } catch (...) {
56529       {
56530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56531       };
56532     }
56533   }
56534
56535   jresult = result;
56536   return jresult;
56537 }
56538
56539
56540 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56541   unsigned long jresult ;
56542   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56543   std::size_t result;
56544
56545   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56546   {
56547     try {
56548       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56549     } catch (std::out_of_range& e) {
56550       {
56551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56552       };
56553     } catch (std::exception& e) {
56554       {
56555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56556       };
56557     } catch (Dali::DaliException e) {
56558       {
56559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56560       };
56561     } catch (...) {
56562       {
56563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56564       };
56565     }
56566   }
56567
56568   jresult = (unsigned long)result;
56569   return jresult;
56570 }
56571
56572
56573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56574   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56575   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56576
56577   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56578   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56579   {
56580     try {
56581       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56582     } catch (std::out_of_range& e) {
56583       {
56584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56585       };
56586     } catch (std::exception& e) {
56587       {
56588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56589       };
56590     } catch (Dali::DaliException e) {
56591       {
56592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56593       };
56594     } catch (...) {
56595       {
56596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56597       };
56598     }
56599   }
56600
56601 }
56602
56603
56604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56605   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56606   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56607
56608   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56609   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56610   {
56611     try {
56612       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56613     } catch (std::out_of_range& e) {
56614       {
56615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56616       };
56617     } catch (std::exception& e) {
56618       {
56619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56620       };
56621     } catch (Dali::DaliException e) {
56622       {
56623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56624       };
56625     } catch (...) {
56626       {
56627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56628       };
56629     }
56630   }
56631
56632 }
56633
56634
56635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56636   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56637   Dali::TouchData *arg2 = 0 ;
56638
56639   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56640   arg2 = (Dali::TouchData *)jarg2;
56641   if (!arg2) {
56642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56643     return ;
56644   }
56645   {
56646     try {
56647       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56648     } catch (std::out_of_range& e) {
56649       {
56650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56651       };
56652     } catch (std::exception& e) {
56653       {
56654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56655       };
56656     } catch (Dali::DaliException e) {
56657       {
56658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56659       };
56660     } catch (...) {
56661       {
56662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56663       };
56664     }
56665   }
56666
56667 }
56668
56669
56670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56671   void * jresult ;
56672   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56673
56674   {
56675     try {
56676       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56677     } catch (std::out_of_range& e) {
56678       {
56679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56680       };
56681     } catch (std::exception& e) {
56682       {
56683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56684       };
56685     } catch (Dali::DaliException e) {
56686       {
56687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56688       };
56689     } catch (...) {
56690       {
56691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56692       };
56693     }
56694   }
56695
56696   jresult = (void *)result;
56697   return jresult;
56698 }
56699
56700
56701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56702   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56703
56704   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56705   {
56706     try {
56707       delete arg1;
56708     } catch (std::out_of_range& e) {
56709       {
56710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56711       };
56712     } catch (std::exception& e) {
56713       {
56714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56715       };
56716     } catch (Dali::DaliException e) {
56717       {
56718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56719       };
56720     } catch (...) {
56721       {
56722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56723       };
56724     }
56725   }
56726
56727 }
56728
56729
56730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56731   unsigned int jresult ;
56732   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56733   bool result;
56734
56735   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56736   {
56737     try {
56738       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56739     } catch (std::out_of_range& e) {
56740       {
56741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56742       };
56743     } catch (std::exception& e) {
56744       {
56745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56746       };
56747     } catch (Dali::DaliException e) {
56748       {
56749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56750       };
56751     } catch (...) {
56752       {
56753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56754       };
56755     }
56756   }
56757
56758   jresult = result;
56759   return jresult;
56760 }
56761
56762
56763 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56764   unsigned long jresult ;
56765   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56766   std::size_t result;
56767
56768   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56769   {
56770     try {
56771       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56772     } catch (std::out_of_range& e) {
56773       {
56774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56775       };
56776     } catch (std::exception& e) {
56777       {
56778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56779       };
56780     } catch (Dali::DaliException e) {
56781       {
56782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56783       };
56784     } catch (...) {
56785       {
56786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56787       };
56788     }
56789   }
56790
56791   jresult = (unsigned long)result;
56792   return jresult;
56793 }
56794
56795
56796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56797   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56798   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56799
56800   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56801   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56802   {
56803     try {
56804       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56805     } catch (std::out_of_range& e) {
56806       {
56807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56808       };
56809     } catch (std::exception& e) {
56810       {
56811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56812       };
56813     } catch (Dali::DaliException e) {
56814       {
56815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56816       };
56817     } catch (...) {
56818       {
56819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56820       };
56821     }
56822   }
56823
56824 }
56825
56826
56827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56828   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56829   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56830
56831   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56832   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56833   {
56834     try {
56835       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56836     } catch (std::out_of_range& e) {
56837       {
56838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56839       };
56840     } catch (std::exception& e) {
56841       {
56842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56843       };
56844     } catch (Dali::DaliException e) {
56845       {
56846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56847       };
56848     } catch (...) {
56849       {
56850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56851       };
56852     }
56853   }
56854
56855 }
56856
56857
56858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56859   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56860   Dali::WheelEvent *arg2 = 0 ;
56861
56862   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56863   arg2 = (Dali::WheelEvent *)jarg2;
56864   if (!arg2) {
56865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56866     return ;
56867   }
56868   {
56869     try {
56870       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56871     } catch (std::out_of_range& e) {
56872       {
56873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56874       };
56875     } catch (std::exception& e) {
56876       {
56877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56878       };
56879     } catch (Dali::DaliException e) {
56880       {
56881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56882       };
56883     } catch (...) {
56884       {
56885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56886       };
56887     }
56888   }
56889
56890 }
56891
56892
56893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56894   void * jresult ;
56895   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56896
56897   {
56898     try {
56899       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56900     } catch (std::out_of_range& e) {
56901       {
56902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56903       };
56904     } catch (std::exception& e) {
56905       {
56906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56907       };
56908     } catch (Dali::DaliException e) {
56909       {
56910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56911       };
56912     } catch (...) {
56913       {
56914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56915       };
56916     }
56917   }
56918
56919   jresult = (void *)result;
56920   return jresult;
56921 }
56922
56923
56924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56925   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56926
56927   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56928   {
56929     try {
56930       delete arg1;
56931     } catch (std::out_of_range& e) {
56932       {
56933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56934       };
56935     } catch (std::exception& e) {
56936       {
56937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56938       };
56939     } catch (Dali::DaliException e) {
56940       {
56941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56942       };
56943     } catch (...) {
56944       {
56945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56946       };
56947     }
56948   }
56949
56950 }
56951
56952
56953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56954   void * jresult ;
56955   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56956
56957   {
56958     try {
56959       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56960     } catch (std::out_of_range& e) {
56961       {
56962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56963       };
56964     } catch (std::exception& e) {
56965       {
56966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56967       };
56968     } catch (Dali::DaliException e) {
56969       {
56970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56971       };
56972     } catch (...) {
56973       {
56974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56975       };
56976     }
56977   }
56978
56979   jresult = (void *)result;
56980   return jresult;
56981 }
56982
56983
56984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56985   void * jresult ;
56986   Dali::Radian arg1 ;
56987   Dali::Radian arg2 ;
56988   Dali::Radian *argp1 ;
56989   Dali::Radian *argp2 ;
56990   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56991
56992   argp1 = (Dali::Radian *)jarg1;
56993   if (!argp1) {
56994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56995     return 0;
56996   }
56997   arg1 = *argp1;
56998   argp2 = (Dali::Radian *)jarg2;
56999   if (!argp2) {
57000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
57001     return 0;
57002   }
57003   arg2 = *argp2;
57004   {
57005     try {
57006       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
57007     } catch (std::out_of_range& e) {
57008       {
57009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57010       };
57011     } catch (std::exception& e) {
57012       {
57013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57014       };
57015     } catch (Dali::DaliException e) {
57016       {
57017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57018       };
57019     } catch (...) {
57020       {
57021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57022       };
57023     }
57024   }
57025
57026   jresult = (void *)result;
57027   return jresult;
57028 }
57029
57030
57031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
57032   void * jresult ;
57033   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
57034   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57035
57036   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57037   if (!arg1) {
57038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
57039     return 0;
57040   }
57041   {
57042     try {
57043       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
57044     } catch (std::out_of_range& e) {
57045       {
57046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57047       };
57048     } catch (std::exception& e) {
57049       {
57050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57051       };
57052     } catch (Dali::DaliException e) {
57053       {
57054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57055       };
57056     } catch (...) {
57057       {
57058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57059       };
57060     }
57061   }
57062
57063   jresult = (void *)result;
57064   return jresult;
57065 }
57066
57067
57068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
57069   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57070   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57071
57072   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57073   arg2 = (Dali::Radian *)jarg2;
57074   if (arg1) (arg1)->first = *arg2;
57075 }
57076
57077
57078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
57079   void * jresult ;
57080   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57081   Dali::Radian *result = 0 ;
57082
57083   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57084   result = (Dali::Radian *)& ((arg1)->first);
57085   jresult = (void *)result;
57086   return jresult;
57087 }
57088
57089
57090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57091   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57092   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57093
57094   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57095   arg2 = (Dali::Radian *)jarg2;
57096   if (arg1) (arg1)->second = *arg2;
57097 }
57098
57099
57100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57101   void * jresult ;
57102   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57103   Dali::Radian *result = 0 ;
57104
57105   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57106   result = (Dali::Radian *)& ((arg1)->second);
57107   jresult = (void *)result;
57108   return jresult;
57109 }
57110
57111
57112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57113   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57114
57115   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57116   {
57117     try {
57118       delete arg1;
57119     } catch (std::out_of_range& e) {
57120       {
57121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57122       };
57123     } catch (std::exception& e) {
57124       {
57125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57126       };
57127     } catch (Dali::DaliException e) {
57128       {
57129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57130       };
57131     } catch (...) {
57132       {
57133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57134       };
57135     }
57136   }
57137
57138 }
57139
57140
57141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57142   unsigned int jresult ;
57143   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57144   bool result;
57145
57146   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57147   {
57148     try {
57149       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *)arg1);
57150     } catch (std::out_of_range& e) {
57151       {
57152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57153       };
57154     } catch (std::exception& e) {
57155       {
57156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57157       };
57158     } catch (Dali::DaliException e) {
57159       {
57160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57161       };
57162     } catch (...) {
57163       {
57164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57165       };
57166     }
57167   }
57168
57169   jresult = result;
57170   return jresult;
57171 }
57172
57173
57174 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57175   unsigned long jresult ;
57176   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57177   std::size_t result;
57178
57179   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57180   {
57181     try {
57182       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *)arg1);
57183     } catch (std::out_of_range& e) {
57184       {
57185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57186       };
57187     } catch (std::exception& e) {
57188       {
57189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57190       };
57191     } catch (Dali::DaliException e) {
57192       {
57193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57194       };
57195     } catch (...) {
57196       {
57197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57198       };
57199     }
57200   }
57201
57202   jresult = (unsigned long)result;
57203   return jresult;
57204 }
57205
57206
57207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57208   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57209   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57210
57211   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57212   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57213   {
57214     try {
57215       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57216     } catch (std::out_of_range& e) {
57217       {
57218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57219       };
57220     } catch (std::exception& e) {
57221       {
57222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57223       };
57224     } catch (Dali::DaliException e) {
57225       {
57226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57227       };
57228     } catch (...) {
57229       {
57230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57231       };
57232     }
57233   }
57234
57235 }
57236
57237
57238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57239   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57240   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57241
57242   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57243   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57244   {
57245     try {
57246       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57247     } catch (std::out_of_range& e) {
57248       {
57249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57250       };
57251     } catch (std::exception& e) {
57252       {
57253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57254       };
57255     } catch (Dali::DaliException e) {
57256       {
57257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57258       };
57259     } catch (...) {
57260       {
57261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57262       };
57263     }
57264   }
57265
57266 }
57267
57268
57269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57270   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57271   Dali::Actor arg2 ;
57272   Dali::PanGesture *arg3 = 0 ;
57273   Dali::Actor *argp2 ;
57274
57275   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57276   argp2 = (Dali::Actor *)jarg2;
57277   if (!argp2) {
57278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57279     return ;
57280   }
57281   arg2 = *argp2;
57282   arg3 = (Dali::PanGesture *)jarg3;
57283   if (!arg3) {
57284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57285     return ;
57286   }
57287   {
57288     try {
57289       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57290     } catch (std::out_of_range& e) {
57291       {
57292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57293       };
57294     } catch (std::exception& e) {
57295       {
57296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57297       };
57298     } catch (Dali::DaliException e) {
57299       {
57300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57301       };
57302     } catch (...) {
57303       {
57304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57305       };
57306     }
57307   }
57308
57309 }
57310
57311
57312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57313   void * jresult ;
57314   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57315
57316   {
57317     try {
57318       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57319     } catch (std::out_of_range& e) {
57320       {
57321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57322       };
57323     } catch (std::exception& e) {
57324       {
57325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57326       };
57327     } catch (Dali::DaliException e) {
57328       {
57329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57330       };
57331     } catch (...) {
57332       {
57333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57334       };
57335     }
57336   }
57337
57338   jresult = (void *)result;
57339   return jresult;
57340 }
57341
57342
57343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57344   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57345
57346   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57347   {
57348     try {
57349       delete arg1;
57350     } catch (std::out_of_range& e) {
57351       {
57352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57353       };
57354     } catch (std::exception& e) {
57355       {
57356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57357       };
57358     } catch (Dali::DaliException e) {
57359       {
57360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57361       };
57362     } catch (...) {
57363       {
57364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57365       };
57366     }
57367   }
57368
57369 }
57370
57371
57372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57373   unsigned int jresult ;
57374   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57375   bool result;
57376
57377   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57378   {
57379     try {
57380       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *)arg1);
57381     } catch (std::out_of_range& e) {
57382       {
57383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57384       };
57385     } catch (std::exception& e) {
57386       {
57387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57388       };
57389     } catch (Dali::DaliException e) {
57390       {
57391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57392       };
57393     } catch (...) {
57394       {
57395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57396       };
57397     }
57398   }
57399
57400   jresult = result;
57401   return jresult;
57402 }
57403
57404
57405 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57406   unsigned long jresult ;
57407   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57408   std::size_t result;
57409
57410   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57411   {
57412     try {
57413       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *)arg1);
57414     } catch (std::out_of_range& e) {
57415       {
57416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57417       };
57418     } catch (std::exception& e) {
57419       {
57420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57421       };
57422     } catch (Dali::DaliException e) {
57423       {
57424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57425       };
57426     } catch (...) {
57427       {
57428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57429       };
57430     }
57431   }
57432
57433   jresult = (unsigned long)result;
57434   return jresult;
57435 }
57436
57437
57438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57439   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57440   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57441
57442   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57443   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57444   {
57445     try {
57446       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57447     } catch (std::out_of_range& e) {
57448       {
57449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57450       };
57451     } catch (std::exception& e) {
57452       {
57453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57454       };
57455     } catch (Dali::DaliException e) {
57456       {
57457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57458       };
57459     } catch (...) {
57460       {
57461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57462       };
57463     }
57464   }
57465
57466 }
57467
57468
57469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57470   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57471   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57472
57473   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57474   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57475   {
57476     try {
57477       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57478     } catch (std::out_of_range& e) {
57479       {
57480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57481       };
57482     } catch (std::exception& e) {
57483       {
57484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57485       };
57486     } catch (Dali::DaliException e) {
57487       {
57488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57489       };
57490     } catch (...) {
57491       {
57492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57493       };
57494     }
57495   }
57496
57497 }
57498
57499
57500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57501   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57502   Dali::Actor arg2 ;
57503   Dali::PinchGesture *arg3 = 0 ;
57504   Dali::Actor *argp2 ;
57505
57506   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57507   argp2 = (Dali::Actor *)jarg2;
57508   if (!argp2) {
57509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57510     return ;
57511   }
57512   arg2 = *argp2;
57513   arg3 = (Dali::PinchGesture *)jarg3;
57514   if (!arg3) {
57515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57516     return ;
57517   }
57518   {
57519     try {
57520       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57521     } catch (std::out_of_range& e) {
57522       {
57523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57524       };
57525     } catch (std::exception& e) {
57526       {
57527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57528       };
57529     } catch (Dali::DaliException e) {
57530       {
57531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57532       };
57533     } catch (...) {
57534       {
57535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57536       };
57537     }
57538   }
57539
57540 }
57541
57542
57543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57544   void * jresult ;
57545   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57546
57547   {
57548     try {
57549       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57550     } catch (std::out_of_range& e) {
57551       {
57552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57553       };
57554     } catch (std::exception& e) {
57555       {
57556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57557       };
57558     } catch (Dali::DaliException e) {
57559       {
57560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57561       };
57562     } catch (...) {
57563       {
57564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57565       };
57566     }
57567   }
57568
57569   jresult = (void *)result;
57570   return jresult;
57571 }
57572
57573
57574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57575   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57576
57577   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57578   {
57579     try {
57580       delete arg1;
57581     } catch (std::out_of_range& e) {
57582       {
57583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57584       };
57585     } catch (std::exception& e) {
57586       {
57587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57588       };
57589     } catch (Dali::DaliException e) {
57590       {
57591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57592       };
57593     } catch (...) {
57594       {
57595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57596       };
57597     }
57598   }
57599
57600 }
57601
57602
57603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57604   unsigned int jresult ;
57605   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57606   bool result;
57607
57608   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57609   {
57610     try {
57611       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *)arg1);
57612     } catch (std::out_of_range& e) {
57613       {
57614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57615       };
57616     } catch (std::exception& e) {
57617       {
57618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57619       };
57620     } catch (Dali::DaliException e) {
57621       {
57622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57623       };
57624     } catch (...) {
57625       {
57626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57627       };
57628     }
57629   }
57630
57631   jresult = result;
57632   return jresult;
57633 }
57634
57635
57636 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57637   unsigned long jresult ;
57638   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57639   std::size_t result;
57640
57641   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57642   {
57643     try {
57644       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *)arg1);
57645     } catch (std::out_of_range& e) {
57646       {
57647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57648       };
57649     } catch (std::exception& e) {
57650       {
57651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57652       };
57653     } catch (Dali::DaliException e) {
57654       {
57655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57656       };
57657     } catch (...) {
57658       {
57659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57660       };
57661     }
57662   }
57663
57664   jresult = (unsigned long)result;
57665   return jresult;
57666 }
57667
57668
57669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57670   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57671   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57672
57673   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57674   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57675   {
57676     try {
57677       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57678     } catch (std::out_of_range& e) {
57679       {
57680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57681       };
57682     } catch (std::exception& e) {
57683       {
57684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57685       };
57686     } catch (Dali::DaliException e) {
57687       {
57688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57689       };
57690     } catch (...) {
57691       {
57692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57693       };
57694     }
57695   }
57696
57697 }
57698
57699
57700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57701   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57702   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57703
57704   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57705   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57706   {
57707     try {
57708       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57709     } catch (std::out_of_range& e) {
57710       {
57711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57712       };
57713     } catch (std::exception& e) {
57714       {
57715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57716       };
57717     } catch (Dali::DaliException e) {
57718       {
57719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57720       };
57721     } catch (...) {
57722       {
57723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57724       };
57725     }
57726   }
57727
57728 }
57729
57730
57731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57732   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57733   Dali::Actor arg2 ;
57734   Dali::TapGesture *arg3 = 0 ;
57735   Dali::Actor *argp2 ;
57736
57737   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57738   argp2 = (Dali::Actor *)jarg2;
57739   if (!argp2) {
57740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57741     return ;
57742   }
57743   arg2 = *argp2;
57744   arg3 = (Dali::TapGesture *)jarg3;
57745   if (!arg3) {
57746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57747     return ;
57748   }
57749   {
57750     try {
57751       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57752     } catch (std::out_of_range& e) {
57753       {
57754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57755       };
57756     } catch (std::exception& e) {
57757       {
57758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57759       };
57760     } catch (Dali::DaliException e) {
57761       {
57762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57763       };
57764     } catch (...) {
57765       {
57766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57767       };
57768     }
57769   }
57770
57771 }
57772
57773
57774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57775   void * jresult ;
57776   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57777
57778   {
57779     try {
57780       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57781     } catch (std::out_of_range& e) {
57782       {
57783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57784       };
57785     } catch (std::exception& e) {
57786       {
57787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57788       };
57789     } catch (Dali::DaliException e) {
57790       {
57791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57792       };
57793     } catch (...) {
57794       {
57795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57796       };
57797     }
57798   }
57799
57800   jresult = (void *)result;
57801   return jresult;
57802 }
57803
57804
57805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57806   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57807
57808   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57809   {
57810     try {
57811       delete arg1;
57812     } catch (std::out_of_range& e) {
57813       {
57814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57815       };
57816     } catch (std::exception& e) {
57817       {
57818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57819       };
57820     } catch (Dali::DaliException e) {
57821       {
57822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57823       };
57824     } catch (...) {
57825       {
57826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57827       };
57828     }
57829   }
57830
57831 }
57832
57833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57834   unsigned int jresult ;
57835   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57836   bool result;
57837
57838   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57839   {
57840     try {
57841       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57842     } catch (std::out_of_range& e) {
57843       {
57844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57845       };
57846     } catch (std::exception& e) {
57847       {
57848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57849       };
57850     } catch (Dali::DaliException e) {
57851       {
57852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57853       };
57854     } catch (...) {
57855       {
57856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57857       };
57858     }
57859   }
57860
57861   jresult = result;
57862   return jresult;
57863 }
57864
57865
57866 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57867   unsigned long jresult ;
57868   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57869   std::size_t result;
57870
57871   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57872   {
57873     try {
57874       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57875     } catch (std::out_of_range& e) {
57876       {
57877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57878       };
57879     } catch (std::exception& e) {
57880       {
57881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57882       };
57883     } catch (Dali::DaliException e) {
57884       {
57885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57886       };
57887     } catch (...) {
57888       {
57889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57890       };
57891     }
57892   }
57893
57894   jresult = (unsigned long)result;
57895   return jresult;
57896 }
57897
57898
57899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57900   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57901   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57902
57903   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57904   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57905   {
57906     try {
57907       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57908     } catch (std::out_of_range& e) {
57909       {
57910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57911       };
57912     } catch (std::exception& e) {
57913       {
57914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57915       };
57916     } catch (Dali::DaliException e) {
57917       {
57918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57919       };
57920     } catch (...) {
57921       {
57922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57923       };
57924     }
57925   }
57926
57927 }
57928
57929
57930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57931   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57932   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57933
57934   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57935   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57936   {
57937     try {
57938       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57939     } catch (std::out_of_range& e) {
57940       {
57941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57942       };
57943     } catch (std::exception& e) {
57944       {
57945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57946       };
57947     } catch (Dali::DaliException e) {
57948       {
57949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57950       };
57951     } catch (...) {
57952       {
57953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57954       };
57955     }
57956   }
57957
57958 }
57959
57960
57961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57962   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57963   Dali::ResourceImage arg2 ;
57964   Dali::ResourceImage *argp2 ;
57965
57966   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57967   argp2 = (Dali::ResourceImage *)jarg2;
57968   if (!argp2) {
57969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57970     return ;
57971   }
57972   arg2 = *argp2;
57973   {
57974     try {
57975       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57976     } catch (std::out_of_range& e) {
57977       {
57978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57979       };
57980     } catch (std::exception& e) {
57981       {
57982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57983       };
57984     } catch (Dali::DaliException e) {
57985       {
57986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57987       };
57988     } catch (...) {
57989       {
57990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57991       };
57992     }
57993   }
57994
57995 }
57996
57997
57998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57999   void * jresult ;
58000   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
58001
58002   {
58003     try {
58004       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
58005     } catch (std::out_of_range& e) {
58006       {
58007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58008       };
58009     } catch (std::exception& e) {
58010       {
58011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58012       };
58013     } catch (Dali::DaliException e) {
58014       {
58015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58016       };
58017     } catch (...) {
58018       {
58019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58020       };
58021     }
58022   }
58023
58024   jresult = (void *)result;
58025   return jresult;
58026 }
58027
58028
58029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
58030   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
58031
58032   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58033   {
58034     try {
58035       delete arg1;
58036     } catch (std::out_of_range& e) {
58037       {
58038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58039       };
58040     } catch (std::exception& e) {
58041       {
58042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58043       };
58044     } catch (Dali::DaliException e) {
58045       {
58046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58047       };
58048     } catch (...) {
58049       {
58050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58051       };
58052     }
58053   }
58054
58055 }
58056
58057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
58058   unsigned int jresult ;
58059   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58060   bool result = false;
58061
58062   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58063   {
58064     try {
58065       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *)arg1);
58066     } catch (std::out_of_range& e) {
58067       {
58068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58069       };
58070     } catch (std::exception& e) {
58071       {
58072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58073       };
58074     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58075   }
58076   jresult = result;
58077   return jresult;
58078 }
58079
58080 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
58081   unsigned long jresult ;
58082   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58083   std::size_t result = 0;
58084
58085   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58086   {
58087     try {
58088       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *)arg1);
58089     } catch (std::out_of_range& e) {
58090       {
58091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58092       };
58093     } catch (std::exception& e) {
58094       {
58095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58096       };
58097     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58098   }
58099   jresult = (unsigned long)result;
58100   return jresult;
58101 }
58102
58103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58104   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58105   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58106
58107   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58108   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58109   {
58110     try {
58111       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58112     } catch (std::out_of_range& e) {
58113       {
58114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58115       };
58116     } catch (std::exception& e) {
58117       {
58118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58119       };
58120     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58121   }
58122 }
58123
58124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58125   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58126   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58127
58128   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58129   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58130   {
58131     try {
58132       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58133     } catch (std::out_of_range& e) {
58134       {
58135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58136       };
58137     } catch (std::exception& e) {
58138       {
58139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58140       };
58141     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58142   }
58143 }
58144
58145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58146   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58147   Dali::Actor arg2 ;
58148   //bool arg3 ;
58149   Dali::LayoutDirection::Type arg4 ;
58150   Dali::Actor *argp2 ;
58151
58152   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58153   argp2 = (Dali::Actor *)jarg2;
58154   if (!argp2) {
58155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58156     return ;
58157   }
58158   arg2 = *argp2;
58159   //arg3 = jarg3 ? true : false;
58160   arg4 = (Dali::LayoutDirection::Type)jarg4;
58161   {
58162     try {
58163       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58164     } catch (std::out_of_range& e) {
58165       {
58166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58167       };
58168     } catch (std::exception& e) {
58169       {
58170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58171       };
58172     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58173   }
58174 }
58175
58176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58177   void * jresult ;
58178   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58179
58180   {
58181     try {
58182       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58183     } catch (std::out_of_range& e) {
58184       {
58185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58186       };
58187     } catch (std::exception& e) {
58188       {
58189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58190       };
58191     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58192   }
58193   jresult = (void *)result;
58194   return jresult;
58195 }
58196
58197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58198   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58199
58200   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58201   {
58202     try {
58203       delete arg1;
58204     } catch (std::out_of_range& e) {
58205       {
58206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58207       };
58208     } catch (std::exception& e) {
58209       {
58210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58211       };
58212     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58213   }
58214 }
58215
58216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58217   unsigned int jresult ;
58218   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58219   bool result;
58220
58221   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58222   {
58223     try {
58224       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
58225     } catch (std::out_of_range& e) {
58226       {
58227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58228       };
58229     } catch (std::exception& e) {
58230       {
58231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58232       };
58233     } catch (Dali::DaliException e) {
58234       {
58235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58236       };
58237     } catch (...) {
58238       {
58239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58240       };
58241     }
58242   }
58243
58244   jresult = result;
58245   return jresult;
58246 }
58247
58248
58249 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58250   unsigned long jresult ;
58251   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58252   std::size_t result;
58253
58254   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58255   {
58256     try {
58257       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
58258     } catch (std::out_of_range& e) {
58259       {
58260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58261       };
58262     } catch (std::exception& e) {
58263       {
58264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58265       };
58266     } catch (Dali::DaliException e) {
58267       {
58268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58269       };
58270     } catch (...) {
58271       {
58272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58273       };
58274     }
58275   }
58276
58277   jresult = (unsigned long)result;
58278   return jresult;
58279 }
58280
58281
58282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58283   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58284   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58285
58286   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58287   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58288   {
58289     try {
58290       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58291     } catch (std::out_of_range& e) {
58292       {
58293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58294       };
58295     } catch (std::exception& e) {
58296       {
58297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58298       };
58299     } catch (Dali::DaliException e) {
58300       {
58301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58302       };
58303     } catch (...) {
58304       {
58305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58306       };
58307     }
58308   }
58309
58310 }
58311
58312
58313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58314   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58315   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58316
58317   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58318   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58319   {
58320     try {
58321       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58322     } catch (std::out_of_range& e) {
58323       {
58324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58325       };
58326     } catch (std::exception& e) {
58327       {
58328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58329       };
58330     } catch (Dali::DaliException e) {
58331       {
58332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58333       };
58334     } catch (...) {
58335       {
58336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58337       };
58338     }
58339   }
58340
58341 }
58342
58343
58344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58345   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58346   Dali::Actor arg2 ;
58347   bool arg3 ;
58348   Dali::DevelActor::VisibilityChange::Type arg4 ;
58349   Dali::Actor *argp2 ;
58350
58351   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58352   argp2 = (Dali::Actor *)jarg2;
58353   if (!argp2) {
58354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58355     return ;
58356   }
58357   arg2 = *argp2;
58358   arg3 = jarg3 ? true : false;
58359   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58360   {
58361     try {
58362       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58363     } catch (std::out_of_range& e) {
58364       {
58365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58366       };
58367     } catch (std::exception& e) {
58368       {
58369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58370       };
58371     } catch (Dali::DaliException e) {
58372       {
58373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58374       };
58375     } catch (...) {
58376       {
58377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58378       };
58379     }
58380   }
58381
58382 }
58383
58384
58385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58386   void * jresult ;
58387   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58388
58389   {
58390     try {
58391       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58392     } catch (std::out_of_range& e) {
58393       {
58394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58395       };
58396     } catch (std::exception& e) {
58397       {
58398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58399       };
58400     } catch (Dali::DaliException e) {
58401       {
58402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58403       };
58404     } catch (...) {
58405       {
58406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58407       };
58408     }
58409   }
58410
58411   jresult = (void *)result;
58412   return jresult;
58413 }
58414
58415
58416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58417   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58418
58419   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58420   {
58421     try {
58422       delete arg1;
58423     } catch (std::out_of_range& e) {
58424       {
58425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58426       };
58427     } catch (std::exception& e) {
58428       {
58429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58430       };
58431     } catch (Dali::DaliException e) {
58432       {
58433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58434       };
58435     } catch (...) {
58436       {
58437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58438       };
58439     }
58440   }
58441
58442 }
58443
58444
58445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58446   void * jresult ;
58447   Dali::Timer *result = 0 ;
58448
58449   {
58450     try {
58451       result = (Dali::Timer *)new Dali::Timer();
58452     } catch (std::out_of_range& e) {
58453       {
58454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58455       };
58456     } catch (std::exception& e) {
58457       {
58458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58459       };
58460     } catch (Dali::DaliException e) {
58461       {
58462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58463       };
58464     } catch (...) {
58465       {
58466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58467       };
58468     }
58469   }
58470
58471   jresult = (void *)result;
58472   return jresult;
58473 }
58474
58475
58476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58477   void * jresult ;
58478   unsigned int arg1 ;
58479   Dali::Timer result;
58480
58481   arg1 = (unsigned int)jarg1;
58482   {
58483     try {
58484       result = Dali::Timer::New(arg1);
58485     } catch (std::out_of_range& e) {
58486       {
58487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58488       };
58489     } catch (std::exception& e) {
58490       {
58491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58492       };
58493     } catch (Dali::DaliException e) {
58494       {
58495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58496       };
58497     } catch (...) {
58498       {
58499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58500       };
58501     }
58502   }
58503
58504   jresult = new Dali::Timer((const Dali::Timer &)result);
58505   return jresult;
58506 }
58507
58508
58509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58510   void * jresult ;
58511   Dali::Timer *arg1 = 0 ;
58512   Dali::Timer *result = 0 ;
58513
58514   arg1 = (Dali::Timer *)jarg1;
58515   if (!arg1) {
58516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58517     return 0;
58518   }
58519   {
58520     try {
58521       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58522     } catch (std::out_of_range& e) {
58523       {
58524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58525       };
58526     } catch (std::exception& e) {
58527       {
58528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58529       };
58530     } catch (Dali::DaliException e) {
58531       {
58532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58533       };
58534     } catch (...) {
58535       {
58536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58537       };
58538     }
58539   }
58540
58541   jresult = (void *)result;
58542   return jresult;
58543 }
58544
58545
58546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58547   void * jresult ;
58548   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58549   Dali::Timer *arg2 = 0 ;
58550   Dali::Timer *result = 0 ;
58551
58552   arg1 = (Dali::Timer *)jarg1;
58553   arg2 = (Dali::Timer *)jarg2;
58554   if (!arg2) {
58555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58556     return 0;
58557   }
58558   {
58559     try {
58560       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58561     } catch (std::out_of_range& e) {
58562       {
58563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58564       };
58565     } catch (std::exception& e) {
58566       {
58567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58568       };
58569     } catch (Dali::DaliException e) {
58570       {
58571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58572       };
58573     } catch (...) {
58574       {
58575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58576       };
58577     }
58578   }
58579
58580   jresult = (void *)result;
58581   return jresult;
58582 }
58583
58584
58585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58586   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58587
58588   arg1 = (Dali::Timer *)jarg1;
58589   {
58590     try {
58591       delete arg1;
58592     } catch (std::out_of_range& e) {
58593       {
58594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58595       };
58596     } catch (std::exception& e) {
58597       {
58598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58599       };
58600     } catch (Dali::DaliException e) {
58601       {
58602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58603       };
58604     } catch (...) {
58605       {
58606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58607       };
58608     }
58609   }
58610
58611 }
58612
58613
58614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58615   void * jresult ;
58616   Dali::BaseHandle arg1 ;
58617   Dali::BaseHandle *argp1 ;
58618   Dali::Timer result;
58619
58620   argp1 = (Dali::BaseHandle *)jarg1;
58621   if (!argp1) {
58622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58623     return 0;
58624   }
58625   arg1 = *argp1;
58626   {
58627     try {
58628       result = Dali::Timer::DownCast(arg1);
58629     } catch (std::out_of_range& e) {
58630       {
58631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58632       };
58633     } catch (std::exception& e) {
58634       {
58635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58636       };
58637     } catch (Dali::DaliException e) {
58638       {
58639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58640       };
58641     } catch (...) {
58642       {
58643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58644       };
58645     }
58646   }
58647
58648   jresult = new Dali::Timer((const Dali::Timer &)result);
58649   return jresult;
58650 }
58651
58652
58653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58654   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58655
58656   arg1 = (Dali::Timer *)jarg1;
58657   {
58658     try {
58659       (arg1)->Start();
58660     } catch (std::out_of_range& e) {
58661       {
58662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58663       };
58664     } catch (std::exception& e) {
58665       {
58666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58667       };
58668     } catch (Dali::DaliException e) {
58669       {
58670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58671       };
58672     } catch (...) {
58673       {
58674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58675       };
58676     }
58677   }
58678
58679 }
58680
58681
58682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58683   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58684
58685   arg1 = (Dali::Timer *)jarg1;
58686   {
58687     try {
58688       (arg1)->Stop();
58689     } catch (std::out_of_range& e) {
58690       {
58691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58692       };
58693     } catch (std::exception& e) {
58694       {
58695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58696       };
58697     } catch (Dali::DaliException e) {
58698       {
58699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58700       };
58701     } catch (...) {
58702       {
58703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58704       };
58705     }
58706   }
58707
58708 }
58709
58710
58711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58712   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58713   unsigned int arg2 ;
58714
58715   arg1 = (Dali::Timer *)jarg1;
58716   arg2 = (unsigned int)jarg2;
58717   {
58718     try {
58719       (arg1)->SetInterval(arg2);
58720     } catch (std::out_of_range& e) {
58721       {
58722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58723       };
58724     } catch (std::exception& e) {
58725       {
58726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58727       };
58728     } catch (Dali::DaliException e) {
58729       {
58730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58731       };
58732     } catch (...) {
58733       {
58734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58735       };
58736     }
58737   }
58738
58739 }
58740
58741
58742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58743   unsigned int jresult ;
58744   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58745   unsigned int result;
58746
58747   arg1 = (Dali::Timer *)jarg1;
58748   {
58749     try {
58750       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58751     } catch (std::out_of_range& e) {
58752       {
58753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58754       };
58755     } catch (std::exception& e) {
58756       {
58757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58758       };
58759     } catch (Dali::DaliException e) {
58760       {
58761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58762       };
58763     } catch (...) {
58764       {
58765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58766       };
58767     }
58768   }
58769
58770   jresult = result;
58771   return jresult;
58772 }
58773
58774
58775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58776   unsigned int jresult ;
58777   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58778   bool result;
58779
58780   arg1 = (Dali::Timer *)jarg1;
58781   {
58782     try {
58783       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58784     } catch (std::out_of_range& e) {
58785       {
58786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58787       };
58788     } catch (std::exception& e) {
58789       {
58790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58791       };
58792     } catch (Dali::DaliException e) {
58793       {
58794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58795       };
58796     } catch (...) {
58797       {
58798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58799       };
58800     }
58801   }
58802
58803   jresult = result;
58804   return jresult;
58805 }
58806
58807
58808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58809   void * jresult ;
58810   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58811   Dali::Timer::TimerSignalType *result = 0 ;
58812
58813   arg1 = (Dali::Timer *)jarg1;
58814   {
58815     try {
58816       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58817     } catch (std::out_of_range& e) {
58818       {
58819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58820       };
58821     } catch (std::exception& e) {
58822       {
58823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58824       };
58825     } catch (Dali::DaliException e) {
58826       {
58827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58828       };
58829     } catch (...) {
58830       {
58831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58832       };
58833     }
58834   }
58835
58836   jresult = (void *)result;
58837   return jresult;
58838 }
58839
58840
58841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
58842   unsigned int jresult ;
58843   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58844   bool result;
58845
58846   arg1 = (Dali::Signal< bool () > *)jarg1;
58847   {
58848     try {
58849       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
58850     } catch (std::out_of_range& e) {
58851       {
58852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58853       };
58854     } catch (std::exception& e) {
58855       {
58856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58857       };
58858     } catch (Dali::DaliException e) {
58859       {
58860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58861       };
58862     } catch (...) {
58863       {
58864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58865       };
58866     }
58867   }
58868
58869   jresult = result;
58870   return jresult;
58871 }
58872
58873
58874 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
58875   unsigned long jresult ;
58876   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58877   std::size_t result;
58878
58879   arg1 = (Dali::Signal< bool () > *)jarg1;
58880   {
58881     try {
58882       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
58883     } catch (std::out_of_range& e) {
58884       {
58885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58886       };
58887     } catch (std::exception& e) {
58888       {
58889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58890       };
58891     } catch (Dali::DaliException e) {
58892       {
58893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58894       };
58895     } catch (...) {
58896       {
58897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58898       };
58899     }
58900   }
58901
58902   jresult = (unsigned long)result;
58903   return jresult;
58904 }
58905
58906
58907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
58908   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58909   bool (*arg2)() = (bool (*)()) 0 ;
58910
58911   arg1 = (Dali::Signal< bool () > *)jarg1;
58912   arg2 = (bool (*)())jarg2;
58913   {
58914     try {
58915       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
58916     } catch (std::out_of_range& e) {
58917       {
58918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58919       };
58920     } catch (std::exception& e) {
58921       {
58922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58923       };
58924     } catch (Dali::DaliException e) {
58925       {
58926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58927       };
58928     } catch (...) {
58929       {
58930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58931       };
58932     }
58933   }
58934
58935 }
58936
58937
58938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
58939   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58940   bool (*arg2)() = (bool (*)()) 0 ;
58941
58942   arg1 = (Dali::Signal< bool () > *)jarg1;
58943   arg2 = (bool (*)())jarg2;
58944   {
58945     try {
58946       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
58947     } catch (std::out_of_range& e) {
58948       {
58949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58950       };
58951     } catch (std::exception& e) {
58952       {
58953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58954       };
58955     } catch (Dali::DaliException e) {
58956       {
58957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58958       };
58959     } catch (...) {
58960       {
58961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58962       };
58963     }
58964   }
58965
58966 }
58967
58968
58969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
58970   unsigned int jresult ;
58971   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58972   bool result;
58973
58974   arg1 = (Dali::Signal< bool () > *)jarg1;
58975   {
58976     try {
58977       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
58978     } catch (std::out_of_range& e) {
58979       {
58980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58981       };
58982     } catch (std::exception& e) {
58983       {
58984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58985       };
58986     } catch (Dali::DaliException e) {
58987       {
58988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58989       };
58990     } catch (...) {
58991       {
58992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58993       };
58994     }
58995   }
58996
58997   jresult = result;
58998   return jresult;
58999 }
59000
59001
59002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59003   void * jresult ;
59004   Dali::Signal< bool () > *result = 0 ;
59005
59006   {
59007     try {
59008       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59009     } catch (std::out_of_range& e) {
59010       {
59011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59012       };
59013     } catch (std::exception& e) {
59014       {
59015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59016       };
59017     } catch (Dali::DaliException e) {
59018       {
59019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59020       };
59021     } catch (...) {
59022       {
59023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59024       };
59025     }
59026   }
59027
59028   jresult = (void *)result;
59029   return jresult;
59030 }
59031
59032
59033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59034   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59035
59036   arg1 = (Dali::Signal< bool () > *)jarg1;
59037   {
59038     try {
59039       delete arg1;
59040     } catch (std::out_of_range& e) {
59041       {
59042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59043       };
59044     } catch (std::exception& e) {
59045       {
59046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59047       };
59048     } catch (Dali::DaliException e) {
59049       {
59050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59051       };
59052     } catch (...) {
59053       {
59054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59055       };
59056     }
59057   }
59058
59059 }
59060
59061
59062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59063   int jresult ;
59064   int result;
59065
59066   {
59067     try {
59068       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59069     } catch (std::out_of_range& e) {
59070       {
59071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59072       };
59073     } catch (std::exception& e) {
59074       {
59075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59076       };
59077     } catch (Dali::DaliException e) {
59078       {
59079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59080       };
59081     } catch (...) {
59082       {
59083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59084       };
59085     }
59086   }
59087
59088   jresult = (int)result;
59089   return jresult;
59090 }
59091
59092
59093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59094   int jresult ;
59095   int result;
59096
59097   {
59098     try {
59099       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59100     } catch (std::out_of_range& e) {
59101       {
59102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59103       };
59104     } catch (std::exception& e) {
59105       {
59106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59107       };
59108     } catch (Dali::DaliException e) {
59109       {
59110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59111       };
59112     } catch (...) {
59113       {
59114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59115       };
59116     }
59117   }
59118
59119   jresult = (int)result;
59120   return jresult;
59121 }
59122
59123
59124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59125   int jresult ;
59126   int result;
59127
59128   {
59129     try {
59130       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59131     } catch (std::out_of_range& e) {
59132       {
59133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59134       };
59135     } catch (std::exception& e) {
59136       {
59137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59138       };
59139     } catch (Dali::DaliException e) {
59140       {
59141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59142       };
59143     } catch (...) {
59144       {
59145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59146       };
59147     }
59148   }
59149
59150   jresult = (int)result;
59151   return jresult;
59152 }
59153
59154
59155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59156   int jresult ;
59157   int result;
59158
59159   {
59160     try {
59161       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59162     } catch (std::out_of_range& e) {
59163       {
59164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59165       };
59166     } catch (std::exception& e) {
59167       {
59168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59169       };
59170     } catch (Dali::DaliException e) {
59171       {
59172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59173       };
59174     } catch (...) {
59175       {
59176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59177       };
59178     }
59179   }
59180
59181   jresult = (int)result;
59182   return jresult;
59183 }
59184
59185
59186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59187   int jresult ;
59188   int result;
59189
59190   {
59191     try {
59192       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59193     } catch (std::out_of_range& e) {
59194       {
59195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59196       };
59197     } catch (std::exception& e) {
59198       {
59199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59200       };
59201     } catch (Dali::DaliException e) {
59202       {
59203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59204       };
59205     } catch (...) {
59206       {
59207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59208       };
59209     }
59210   }
59211
59212   jresult = (int)result;
59213   return jresult;
59214 }
59215
59216
59217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59218   int jresult ;
59219   int result;
59220
59221   {
59222     try {
59223       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59224     } catch (std::out_of_range& e) {
59225       {
59226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59227       };
59228     } catch (std::exception& e) {
59229       {
59230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59231       };
59232     } catch (Dali::DaliException e) {
59233       {
59234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59235       };
59236     } catch (...) {
59237       {
59238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59239       };
59240     }
59241   }
59242
59243   jresult = (int)result;
59244   return jresult;
59245 }
59246
59247
59248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59249   int jresult ;
59250   int result;
59251
59252   {
59253     try {
59254       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59255     } catch (std::out_of_range& e) {
59256       {
59257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59258       };
59259     } catch (std::exception& e) {
59260       {
59261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59262       };
59263     } catch (Dali::DaliException e) {
59264       {
59265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59266       };
59267     } catch (...) {
59268       {
59269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59270       };
59271     }
59272   }
59273
59274   jresult = (int)result;
59275   return jresult;
59276 }
59277
59278
59279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59280   int jresult ;
59281   int result;
59282
59283   {
59284     try {
59285       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59286     } catch (std::out_of_range& e) {
59287       {
59288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59289       };
59290     } catch (std::exception& e) {
59291       {
59292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59293       };
59294     } catch (Dali::DaliException e) {
59295       {
59296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59297       };
59298     } catch (...) {
59299       {
59300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59301       };
59302     }
59303   }
59304
59305   jresult = (int)result;
59306   return jresult;
59307 }
59308
59309
59310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59311   int jresult ;
59312   int result;
59313
59314   {
59315     try {
59316       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59317     } catch (std::out_of_range& e) {
59318       {
59319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59320       };
59321     } catch (std::exception& e) {
59322       {
59323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59324       };
59325     } catch (Dali::DaliException e) {
59326       {
59327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59328       };
59329     } catch (...) {
59330       {
59331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59332       };
59333     }
59334   }
59335
59336   jresult = (int)result;
59337   return jresult;
59338 }
59339
59340
59341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59342   int jresult ;
59343   int result;
59344
59345   {
59346     try {
59347       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59348     } catch (std::out_of_range& e) {
59349       {
59350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59351       };
59352     } catch (std::exception& e) {
59353       {
59354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59355       };
59356     } catch (Dali::DaliException e) {
59357       {
59358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59359       };
59360     } catch (...) {
59361       {
59362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59363       };
59364     }
59365   }
59366
59367   jresult = (int)result;
59368   return jresult;
59369 }
59370
59371
59372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59373   int jresult ;
59374   int result;
59375
59376   {
59377     try {
59378       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59379     } catch (std::out_of_range& e) {
59380       {
59381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59382       };
59383     } catch (std::exception& e) {
59384       {
59385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59386       };
59387     } catch (Dali::DaliException e) {
59388       {
59389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59390       };
59391     } catch (...) {
59392       {
59393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59394       };
59395     }
59396   }
59397
59398   jresult = (int)result;
59399   return jresult;
59400 }
59401
59402
59403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59404   int jresult ;
59405   int result;
59406
59407   {
59408     try {
59409       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59410     } catch (std::out_of_range& e) {
59411       {
59412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59413       };
59414     } catch (std::exception& e) {
59415       {
59416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59417       };
59418     } catch (Dali::DaliException e) {
59419       {
59420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59421       };
59422     } catch (...) {
59423       {
59424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59425       };
59426     }
59427   }
59428
59429   jresult = (int)result;
59430   return jresult;
59431 }
59432
59433
59434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59435   int jresult ;
59436   int result;
59437
59438   {
59439     try {
59440       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59441     } catch (std::out_of_range& e) {
59442       {
59443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59444       };
59445     } catch (std::exception& e) {
59446       {
59447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59448       };
59449     } catch (Dali::DaliException e) {
59450       {
59451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59452       };
59453     } catch (...) {
59454       {
59455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59456       };
59457     }
59458   }
59459
59460   jresult = (int)result;
59461   return jresult;
59462 }
59463
59464
59465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59466   int jresult ;
59467   int result;
59468
59469   {
59470     try {
59471       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59472     } catch (std::out_of_range& e) {
59473       {
59474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59475       };
59476     } catch (std::exception& e) {
59477       {
59478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59479       };
59480     } catch (Dali::DaliException e) {
59481       {
59482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59483       };
59484     } catch (...) {
59485       {
59486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59487       };
59488     }
59489   }
59490
59491   jresult = (int)result;
59492   return jresult;
59493 }
59494
59495
59496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59497   int jresult ;
59498   int result;
59499
59500   {
59501     try {
59502       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59503     } catch (std::out_of_range& e) {
59504       {
59505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59506       };
59507     } catch (std::exception& e) {
59508       {
59509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59510       };
59511     } catch (Dali::DaliException e) {
59512       {
59513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59514       };
59515     } catch (...) {
59516       {
59517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59518       };
59519     }
59520   }
59521
59522   jresult = (int)result;
59523   return jresult;
59524 }
59525
59526
59527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59528   int jresult ;
59529   int result;
59530
59531   {
59532     try {
59533       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59534     } catch (std::out_of_range& e) {
59535       {
59536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59537       };
59538     } catch (std::exception& e) {
59539       {
59540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59541       };
59542     } catch (Dali::DaliException e) {
59543       {
59544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59545       };
59546     } catch (...) {
59547       {
59548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59549       };
59550     }
59551   }
59552
59553   jresult = (int)result;
59554   return jresult;
59555 }
59556
59557
59558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59559   int jresult ;
59560   int result;
59561
59562   {
59563     try {
59564       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59565     } catch (std::out_of_range& e) {
59566       {
59567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59568       };
59569     } catch (std::exception& e) {
59570       {
59571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59572       };
59573     } catch (Dali::DaliException e) {
59574       {
59575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59576       };
59577     } catch (...) {
59578       {
59579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59580       };
59581     }
59582   }
59583
59584   jresult = (int)result;
59585   return jresult;
59586 }
59587
59588
59589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59590   int jresult ;
59591   int result;
59592
59593   {
59594     try {
59595       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59596     } catch (std::out_of_range& e) {
59597       {
59598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59599       };
59600     } catch (std::exception& e) {
59601       {
59602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59603       };
59604     } catch (Dali::DaliException e) {
59605       {
59606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59607       };
59608     } catch (...) {
59609       {
59610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59611       };
59612     }
59613   }
59614
59615   jresult = (int)result;
59616   return jresult;
59617 }
59618
59619
59620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59621   int jresult ;
59622   int result;
59623
59624   {
59625     try {
59626       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59627     } catch (std::out_of_range& e) {
59628       {
59629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59630       };
59631     } catch (std::exception& e) {
59632       {
59633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59634       };
59635     } catch (Dali::DaliException e) {
59636       {
59637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59638       };
59639     } catch (...) {
59640       {
59641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59642       };
59643     }
59644   }
59645
59646   jresult = (int)result;
59647   return jresult;
59648 }
59649
59650
59651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59652   int jresult ;
59653   int result;
59654
59655   {
59656     try {
59657       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59658     } catch (std::out_of_range& e) {
59659       {
59660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59661       };
59662     } catch (std::exception& e) {
59663       {
59664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59665       };
59666     } catch (Dali::DaliException e) {
59667       {
59668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59669       };
59670     } catch (...) {
59671       {
59672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59673       };
59674     }
59675   }
59676
59677   jresult = (int)result;
59678   return jresult;
59679 }
59680
59681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59682   int jresult ;
59683   int result;
59684
59685   {
59686     try {
59687       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59688     } catch (std::out_of_range& e) {
59689       {
59690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59691       };
59692     } catch (std::exception& e) {
59693       {
59694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59695       };
59696     } catch (Dali::DaliException e) {
59697       {
59698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59699       };
59700     } catch (...) {
59701       {
59702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59703       };
59704     }
59705   }
59706
59707   jresult = (int)result;
59708   return jresult;
59709 }
59710
59711
59712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59713   int jresult ;
59714   int result;
59715   {
59716     try
59717     {
59718       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59719     } catch (std::out_of_range& e) {
59720       {
59721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59722       };
59723     } catch (std::exception& e) {
59724       {
59725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59726       };
59727     } catch (Dali::DaliException e) {
59728       {
59729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59730       };
59731     } catch (...) {
59732       {
59733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59734       };
59735     }
59736   }
59737
59738   jresult = (int)result;
59739   return jresult;
59740 }
59741
59742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59743   int jresult ;
59744   int result;
59745   {
59746     try
59747     {
59748       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59749     } catch (std::out_of_range& e) {
59750       {
59751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59752       };
59753     } catch (std::exception& e) {
59754       {
59755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59756       };
59757     } catch (Dali::DaliException e) {
59758       {
59759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59760       };
59761     } catch (...) {
59762       {
59763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59764       };
59765     }
59766   }
59767
59768   jresult = (int)result;
59769   return jresult;
59770 }
59771
59772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59773   int jresult ;
59774   int result;
59775   {
59776     try
59777     {
59778       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59779     } catch (std::out_of_range& e) {
59780       {
59781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59782       };
59783     } catch (std::exception& e) {
59784       {
59785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59786       };
59787     } catch (Dali::DaliException e) {
59788       {
59789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59790       };
59791     } catch (...) {
59792       {
59793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59794       };
59795     }
59796   }
59797
59798   jresult = (int)result;
59799   return jresult;
59800 }
59801
59802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59803   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59804 }
59805
59806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59807   int jresult ;
59808   int result;
59809   {
59810     try
59811     {
59812       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59813     } catch (std::out_of_range& e) {
59814       {
59815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59816       };
59817     } catch (std::exception& e) {
59818       {
59819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59820       };
59821     } catch (Dali::DaliException e) {
59822       {
59823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59824       };
59825     } catch (...) {
59826       {
59827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59828       };
59829     }
59830   }
59831
59832   jresult = (int)result;
59833   return jresult;
59834 }
59835
59836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
59837   int jresult ;
59838   int result;
59839   {
59840     try
59841     {
59842       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
59843     } catch (std::out_of_range& e) {
59844       {
59845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59846       };
59847     } catch (std::exception& e) {
59848       {
59849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59850       };
59851     } catch (Dali::DaliException e) {
59852       {
59853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59854       };
59855     } catch (...) {
59856       {
59857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59858       };
59859     }
59860   }
59861
59862   jresult = (int)result;
59863   return jresult;
59864 }
59865
59866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
59867   int jresult ;
59868   int result;
59869
59870   {
59871     try {
59872       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
59873     } catch (std::out_of_range& e) {
59874       {
59875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59876       };
59877     } catch (std::exception& e) {
59878       {
59879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59880       };
59881     } catch (Dali::DaliException e) {
59882       {
59883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59884       };
59885     } catch (...) {
59886       {
59887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59888       };
59889     }
59890   }
59891
59892   jresult = (int)result;
59893   return jresult;
59894 }
59895
59896
59897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
59898   int jresult ;
59899   int result;
59900
59901   {
59902     try {
59903       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
59904     } catch (std::out_of_range& e) {
59905       {
59906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59907       };
59908     } catch (std::exception& e) {
59909       {
59910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59911       };
59912     } catch (Dali::DaliException e) {
59913       {
59914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59915       };
59916     } catch (...) {
59917       {
59918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59919       };
59920     }
59921   }
59922
59923   jresult = (int)result;
59924   return jresult;
59925 }
59926
59927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
59928   int jresult ;
59929   int result;
59930   {
59931     try
59932     {
59933       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
59934     } catch (std::out_of_range& e) {
59935       {
59936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59937       };
59938     } catch (std::exception& e) {
59939       {
59940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59941       };
59942     } catch (...) {
59943       {
59944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59945       };
59946     }
59947   }
59948   jresult = (int)result;
59949   return jresult;
59950 }
59951
59952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
59953   int jresult ;
59954   int result;
59955   {
59956     try
59957     {
59958       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
59959     } catch (std::out_of_range& e) {
59960       {
59961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59962       };
59963     } catch (std::exception& e) {
59964       {
59965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59966       };
59967     } catch (...) {
59968       {
59969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59970       };
59971     }
59972   }
59973   jresult = (int)result;
59974   return jresult;
59975 }
59976
59977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
59978   int jresult ;
59979   int result;
59980   {
59981     try
59982     {
59983       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
59984     } catch (std::out_of_range& e) {
59985       {
59986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59987       };
59988     } catch (std::exception& e) {
59989       {
59990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59991       };
59992     } catch (...) {
59993       {
59994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59995       };
59996     }
59997   }
59998   jresult = (int)result;
59999   return jresult;
60000 }
60001
60002
60003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60004   int jresult ;
60005   int result;
60006   {
60007     try
60008     {
60009       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60010     } catch (std::out_of_range& e) {
60011       {
60012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60013       };
60014     } catch (std::exception& e) {
60015       {
60016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60017       };
60018     } catch (...) {
60019       {
60020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60021       };
60022     }
60023   }
60024   jresult = (int)result;
60025   return jresult;
60026 }
60027
60028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60029   int jresult ;
60030   int result;
60031   {
60032     try
60033     {
60034       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60035     } catch (std::out_of_range& e) {
60036       {
60037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60038       };
60039     } catch (std::exception& e) {
60040       {
60041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60042       };
60043     } catch (...) {
60044       {
60045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60046       };
60047     }
60048   }
60049   jresult = (int)result;
60050   return jresult;
60051 }
60052
60053
60054
60055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60056   int jresult ;
60057   int result;
60058
60059   {
60060     try {
60061       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60062     } catch (std::out_of_range& e) {
60063       {
60064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60065       };
60066     } catch (std::exception& e) {
60067       {
60068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60069       };
60070     } catch (Dali::DaliException e) {
60071       {
60072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60073       };
60074     } catch (...) {
60075       {
60076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60077       };
60078     }
60079   }
60080
60081   jresult = (int)result;
60082   return jresult;
60083 }
60084
60085
60086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60087   int jresult ;
60088   int result;
60089
60090   {
60091     try {
60092       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60093     } catch (std::out_of_range& e) {
60094       {
60095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60096       };
60097     } catch (std::exception& e) {
60098       {
60099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60100       };
60101     } catch (Dali::DaliException e) {
60102       {
60103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60104       };
60105     } catch (...) {
60106       {
60107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60108       };
60109     }
60110   }
60111
60112   jresult = (int)result;
60113   return jresult;
60114 }
60115
60116
60117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60118   int jresult ;
60119   int result;
60120
60121   {
60122     try {
60123       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60124     } catch (std::out_of_range& e) {
60125       {
60126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60127       };
60128     } catch (std::exception& e) {
60129       {
60130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60131       };
60132     } catch (Dali::DaliException e) {
60133       {
60134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60135       };
60136     } catch (...) {
60137       {
60138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60139       };
60140     }
60141   }
60142
60143   jresult = (int)result;
60144   return jresult;
60145 }
60146
60147
60148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60149   int jresult ;
60150   int result;
60151
60152   {
60153     try {
60154       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60155     } catch (std::out_of_range& e) {
60156       {
60157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60158       };
60159     } catch (std::exception& e) {
60160       {
60161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60162       };
60163     } catch (Dali::DaliException e) {
60164       {
60165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60166       };
60167     } catch (...) {
60168       {
60169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60170       };
60171     }
60172   }
60173
60174   jresult = (int)result;
60175   return jresult;
60176 }
60177
60178
60179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60180   int jresult ;
60181   int result;
60182
60183   {
60184     try {
60185       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60186     } catch (std::out_of_range& e) {
60187       {
60188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60189       };
60190     } catch (std::exception& e) {
60191       {
60192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60193       };
60194     } catch (Dali::DaliException e) {
60195       {
60196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60197       };
60198     } catch (...) {
60199       {
60200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60201       };
60202     }
60203   }
60204
60205   jresult = (int)result;
60206   return jresult;
60207 }
60208
60209
60210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60211   int jresult ;
60212   int result;
60213
60214   {
60215     try {
60216       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60217     } catch (std::out_of_range& e) {
60218       {
60219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60220       };
60221     } catch (std::exception& e) {
60222       {
60223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60224       };
60225     } catch (Dali::DaliException e) {
60226       {
60227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60228       };
60229     } catch (...) {
60230       {
60231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60232       };
60233     }
60234   }
60235
60236   jresult = (int)result;
60237   return jresult;
60238 }
60239
60240
60241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60242   int jresult ;
60243   int result;
60244
60245   {
60246     try {
60247       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60248     } catch (std::out_of_range& e) {
60249       {
60250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60251       };
60252     } catch (std::exception& e) {
60253       {
60254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60255       };
60256     } catch (Dali::DaliException e) {
60257       {
60258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60259       };
60260     } catch (...) {
60261       {
60262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60263       };
60264     }
60265   }
60266
60267   jresult = (int)result;
60268   return jresult;
60269 }
60270
60271 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60272   int jresult ;
60273   int result;
60274
60275   {
60276     try {
60277       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60278     } catch (std::out_of_range& e) {
60279       {
60280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60281       };
60282     } catch (std::exception& e) {
60283       {
60284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60285       };
60286     } catch (...) {
60287       {
60288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60289       };
60290     }
60291   }
60292   jresult = (int)result;
60293   return jresult;
60294 }
60295
60296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60297   int jresult ;
60298   int result;
60299
60300   {
60301     try {
60302       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60303     } catch (std::out_of_range& e) {
60304       {
60305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60306       };
60307     } catch (std::exception& e) {
60308       {
60309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60310       };
60311     } catch (Dali::DaliException e) {
60312       {
60313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60314       };
60315     } catch (...) {
60316       {
60317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60318       };
60319     }
60320   }
60321
60322   jresult = (int)result;
60323   return jresult;
60324 }
60325
60326
60327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60328   int jresult ;
60329   int result;
60330
60331   {
60332     try {
60333       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60334     } catch (std::out_of_range& e) {
60335       {
60336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60337       };
60338     } catch (std::exception& e) {
60339       {
60340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60341       };
60342     } catch (Dali::DaliException e) {
60343       {
60344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60345       };
60346     } catch (...) {
60347       {
60348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60349       };
60350     }
60351   }
60352
60353   jresult = (int)result;
60354   return jresult;
60355 }
60356
60357
60358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60359   int jresult ;
60360   int result;
60361
60362   {
60363     try {
60364       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60365     } catch (std::out_of_range& e) {
60366       {
60367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60368       };
60369     } catch (std::exception& e) {
60370       {
60371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60372       };
60373     } catch (Dali::DaliException e) {
60374       {
60375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60376       };
60377     } catch (...) {
60378       {
60379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60380       };
60381     }
60382   }
60383
60384   jresult = (int)result;
60385   return jresult;
60386 }
60387
60388
60389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60390   int jresult ;
60391   int result;
60392
60393   {
60394     try {
60395       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60396     } catch (std::out_of_range& e) {
60397       {
60398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60399       };
60400     } catch (std::exception& e) {
60401       {
60402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60403       };
60404     } catch (Dali::DaliException e) {
60405       {
60406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60407       };
60408     } catch (...) {
60409       {
60410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60411       };
60412     }
60413   }
60414
60415   jresult = (int)result;
60416   return jresult;
60417 }
60418
60419
60420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60421   int jresult ;
60422   int result;
60423
60424   {
60425     try {
60426       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60427     } catch (std::out_of_range& e) {
60428       {
60429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60430       };
60431     } catch (std::exception& e) {
60432       {
60433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60434       };
60435     } catch (Dali::DaliException e) {
60436       {
60437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60438       };
60439     } catch (...) {
60440       {
60441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60442       };
60443     }
60444   }
60445
60446   jresult = (int)result;
60447   return jresult;
60448 }
60449
60450
60451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60452   int jresult ;
60453   int result;
60454
60455   {
60456     try {
60457       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60458     } catch (std::out_of_range& e) {
60459       {
60460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60461       };
60462     } catch (std::exception& e) {
60463       {
60464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60465       };
60466     } catch (Dali::DaliException e) {
60467       {
60468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60469       };
60470     } catch (...) {
60471       {
60472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60473       };
60474     }
60475   }
60476
60477   jresult = (int)result;
60478   return jresult;
60479 }
60480
60481
60482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60483   int jresult ;
60484   int result;
60485
60486   {
60487     try {
60488       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60489     } catch (std::out_of_range& e) {
60490       {
60491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60492       };
60493     } catch (std::exception& e) {
60494       {
60495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60496       };
60497     } catch (Dali::DaliException e) {
60498       {
60499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60500       };
60501     } catch (...) {
60502       {
60503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60504       };
60505     }
60506   }
60507
60508   jresult = (int)result;
60509   return jresult;
60510 }
60511
60512
60513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60514   int jresult ;
60515   int result;
60516
60517   {
60518     try {
60519       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60520     } catch (std::out_of_range& e) {
60521       {
60522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60523       };
60524     } catch (std::exception& e) {
60525       {
60526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60527       };
60528     } catch (Dali::DaliException e) {
60529       {
60530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60531       };
60532     } catch (...) {
60533       {
60534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60535       };
60536     }
60537   }
60538
60539   jresult = (int)result;
60540   return jresult;
60541 }
60542
60543
60544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60545   int jresult ;
60546   int result;
60547
60548   {
60549     try {
60550       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60551     } catch (std::out_of_range& e) {
60552       {
60553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60554       };
60555     } catch (std::exception& e) {
60556       {
60557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60558       };
60559     } catch (Dali::DaliException e) {
60560       {
60561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60562       };
60563     } catch (...) {
60564       {
60565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60566       };
60567     }
60568   }
60569
60570   jresult = (int)result;
60571   return jresult;
60572 }
60573
60574
60575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60576   int jresult ;
60577   int result;
60578
60579   {
60580     try {
60581       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60582     } catch (std::out_of_range& e) {
60583       {
60584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60585       };
60586     } catch (std::exception& e) {
60587       {
60588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60589       };
60590     } catch (Dali::DaliException e) {
60591       {
60592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60593       };
60594     } catch (...) {
60595       {
60596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60597       };
60598     }
60599   }
60600
60601   jresult = (int)result;
60602   return jresult;
60603 }
60604
60605
60606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60607   int jresult ;
60608   int result;
60609
60610   {
60611     try {
60612       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60613     } catch (std::out_of_range& e) {
60614       {
60615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60616       };
60617     } catch (std::exception& e) {
60618       {
60619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60620       };
60621     } catch (Dali::DaliException e) {
60622       {
60623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60624       };
60625     } catch (...) {
60626       {
60627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60628       };
60629     }
60630   }
60631
60632   jresult = (int)result;
60633   return jresult;
60634 }
60635
60636
60637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60638   int jresult ;
60639   int result;
60640
60641   {
60642     try {
60643       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60644     } catch (std::out_of_range& e) {
60645       {
60646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60647       };
60648     } catch (std::exception& e) {
60649       {
60650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60651       };
60652     } catch (Dali::DaliException e) {
60653       {
60654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60655       };
60656     } catch (...) {
60657       {
60658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60659       };
60660     }
60661   }
60662
60663   jresult = (int)result;
60664   return jresult;
60665 }
60666
60667
60668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60669   int jresult ;
60670   int result;
60671
60672   {
60673     try {
60674       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60675     } catch (std::out_of_range& e) {
60676       {
60677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60678       };
60679     } catch (std::exception& e) {
60680       {
60681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60682       };
60683     } catch (Dali::DaliException e) {
60684       {
60685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60686       };
60687     } catch (...) {
60688       {
60689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60690       };
60691     }
60692   }
60693
60694   jresult = (int)result;
60695   return jresult;
60696 }
60697
60698
60699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60700   int jresult ;
60701   int result;
60702
60703   {
60704     try {
60705       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60706     } catch (std::out_of_range& e) {
60707       {
60708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60709       };
60710     } catch (std::exception& e) {
60711       {
60712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60713       };
60714     } catch (Dali::DaliException e) {
60715       {
60716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60717       };
60718     } catch (...) {
60719       {
60720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60721       };
60722     }
60723   }
60724
60725   jresult = (int)result;
60726   return jresult;
60727 }
60728
60729
60730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60731   int jresult ;
60732   int result;
60733
60734   {
60735     try {
60736       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60737     } catch (std::out_of_range& e) {
60738       {
60739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60740       };
60741     } catch (std::exception& e) {
60742       {
60743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60744       };
60745     } catch (Dali::DaliException e) {
60746       {
60747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60748       };
60749     } catch (...) {
60750       {
60751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60752       };
60753     }
60754   }
60755
60756   jresult = (int)result;
60757   return jresult;
60758 }
60759
60760
60761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60762   int jresult ;
60763   int result;
60764
60765   {
60766     try {
60767       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60768     } catch (std::out_of_range& e) {
60769       {
60770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60771       };
60772     } catch (std::exception& e) {
60773       {
60774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60775       };
60776     } catch (Dali::DaliException e) {
60777       {
60778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60779       };
60780     } catch (...) {
60781       {
60782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60783       };
60784     }
60785   }
60786
60787   jresult = (int)result;
60788   return jresult;
60789 }
60790
60791
60792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60793   int jresult ;
60794   int result;
60795
60796   {
60797     try {
60798       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60799     } catch (std::out_of_range& e) {
60800       {
60801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60802       };
60803     } catch (std::exception& e) {
60804       {
60805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60806       };
60807     } catch (Dali::DaliException e) {
60808       {
60809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60810       };
60811     } catch (...) {
60812       {
60813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60814       };
60815     }
60816   }
60817
60818   jresult = (int)result;
60819   return jresult;
60820 }
60821
60822
60823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60824   int jresult ;
60825   int result;
60826
60827   {
60828     try {
60829       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60830     } catch (std::out_of_range& e) {
60831       {
60832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60833       };
60834     } catch (std::exception& e) {
60835       {
60836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60837       };
60838     } catch (Dali::DaliException e) {
60839       {
60840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60841       };
60842     } catch (...) {
60843       {
60844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60845       };
60846     }
60847   }
60848
60849   jresult = (int)result;
60850   return jresult;
60851 }
60852
60853
60854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
60855   int jresult ;
60856   int result;
60857
60858   {
60859     try {
60860       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
60861     } catch (std::out_of_range& e) {
60862       {
60863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60864       };
60865     } catch (std::exception& e) {
60866       {
60867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60868       };
60869     } catch (Dali::DaliException e) {
60870       {
60871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60872       };
60873     } catch (...) {
60874       {
60875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60876       };
60877     }
60878   }
60879
60880   jresult = (int)result;
60881   return jresult;
60882 }
60883
60884
60885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
60886   int jresult ;
60887   int result;
60888
60889   {
60890     try {
60891       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
60892     } catch (std::out_of_range& e) {
60893       {
60894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60895       };
60896     } catch (std::exception& e) {
60897       {
60898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60899       };
60900     } catch (Dali::DaliException e) {
60901       {
60902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60903       };
60904     } catch (...) {
60905       {
60906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60907       };
60908     }
60909   }
60910
60911   jresult = (int)result;
60912   return jresult;
60913 }
60914
60915
60916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
60917   int jresult ;
60918   int result;
60919
60920   {
60921     try {
60922       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
60923     } catch (std::out_of_range& e) {
60924       {
60925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60926       };
60927     } catch (std::exception& e) {
60928       {
60929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60930       };
60931     } catch (Dali::DaliException e) {
60932       {
60933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60934       };
60935     } catch (...) {
60936       {
60937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60938       };
60939     }
60940   }
60941
60942   jresult = (int)result;
60943   return jresult;
60944 }
60945
60946
60947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
60948   int jresult ;
60949   int result;
60950
60951   {
60952     try {
60953       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
60954     } catch (std::out_of_range& e) {
60955       {
60956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60957       };
60958     } catch (std::exception& e) {
60959       {
60960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60961       };
60962     } catch (Dali::DaliException e) {
60963       {
60964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60965       };
60966     } catch (...) {
60967       {
60968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60969       };
60970     }
60971   }
60972
60973   jresult = (int)result;
60974   return jresult;
60975 }
60976
60977
60978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
60979   int jresult ;
60980   int result;
60981
60982   {
60983     try {
60984       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
60985     } catch (std::out_of_range& e) {
60986       {
60987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60988       };
60989     } catch (std::exception& e) {
60990       {
60991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60992       };
60993     } catch (Dali::DaliException e) {
60994       {
60995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60996       };
60997     } catch (...) {
60998       {
60999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61000       };
61001     }
61002   }
61003
61004   jresult = (int)result;
61005   return jresult;
61006 }
61007
61008
61009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61010   int jresult ;
61011   int result;
61012
61013   {
61014     try {
61015       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61016     } catch (std::out_of_range& e) {
61017       {
61018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61019       };
61020     } catch (std::exception& e) {
61021       {
61022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61023       };
61024     } catch (Dali::DaliException e) {
61025       {
61026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61027       };
61028     } catch (...) {
61029       {
61030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61031       };
61032     }
61033   }
61034
61035   jresult = (int)result;
61036   return jresult;
61037 }
61038
61039
61040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61041   int jresult ;
61042   int result;
61043
61044   {
61045     try {
61046       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61047     } catch (std::out_of_range& e) {
61048       {
61049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61050       };
61051     } catch (std::exception& e) {
61052       {
61053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61054       };
61055     } catch (Dali::DaliException e) {
61056       {
61057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61058       };
61059     } catch (...) {
61060       {
61061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61062       };
61063     }
61064   }
61065
61066   jresult = (int)result;
61067   return jresult;
61068 }
61069
61070
61071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61072   int jresult ;
61073   int result;
61074
61075   {
61076     try {
61077       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61078     } catch (std::out_of_range& e) {
61079       {
61080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61081       };
61082     } catch (std::exception& e) {
61083       {
61084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61085       };
61086     } catch (Dali::DaliException e) {
61087       {
61088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61089       };
61090     } catch (...) {
61091       {
61092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61093       };
61094     }
61095   }
61096
61097   jresult = (int)result;
61098   return jresult;
61099 }
61100
61101
61102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61103   int jresult ;
61104   int result;
61105
61106   {
61107     try {
61108       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61109     } catch (std::out_of_range& e) {
61110       {
61111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61112       };
61113     } catch (std::exception& e) {
61114       {
61115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61116       };
61117     } catch (Dali::DaliException e) {
61118       {
61119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61120       };
61121     } catch (...) {
61122       {
61123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61124       };
61125     }
61126   }
61127
61128   jresult = (int)result;
61129   return jresult;
61130 }
61131
61132
61133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61134   int jresult ;
61135   int result;
61136
61137   {
61138     try {
61139       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61140     } catch (std::out_of_range& e) {
61141       {
61142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61143       };
61144     } catch (std::exception& e) {
61145       {
61146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61147       };
61148     } catch (Dali::DaliException e) {
61149       {
61150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61151       };
61152     } catch (...) {
61153       {
61154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61155       };
61156     }
61157   }
61158
61159   jresult = (int)result;
61160   return jresult;
61161 }
61162
61163
61164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61165   void * jresult ;
61166   Dali::Toolkit::Builder *result = 0 ;
61167
61168   {
61169     try {
61170       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61171     } catch (std::out_of_range& e) {
61172       {
61173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61174       };
61175     } catch (std::exception& e) {
61176       {
61177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61178       };
61179     } catch (Dali::DaliException e) {
61180       {
61181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61182       };
61183     } catch (...) {
61184       {
61185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61186       };
61187     }
61188   }
61189
61190   jresult = (void *)result;
61191   return jresult;
61192 }
61193
61194
61195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61196   void * jresult ;
61197   Dali::Toolkit::Builder result;
61198
61199   {
61200     try {
61201       result = Dali::Toolkit::Builder::New();
61202     } catch (std::out_of_range& e) {
61203       {
61204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61205       };
61206     } catch (std::exception& e) {
61207       {
61208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61209       };
61210     } catch (Dali::DaliException e) {
61211       {
61212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61213       };
61214     } catch (...) {
61215       {
61216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61217       };
61218     }
61219   }
61220
61221   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61222   return jresult;
61223 }
61224
61225
61226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61227   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61228
61229   arg1 = (Dali::Toolkit::Builder *)jarg1;
61230   {
61231     try {
61232       delete arg1;
61233     } catch (std::out_of_range& e) {
61234       {
61235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61236       };
61237     } catch (std::exception& e) {
61238       {
61239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61240       };
61241     } catch (Dali::DaliException e) {
61242       {
61243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61244       };
61245     } catch (...) {
61246       {
61247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61248       };
61249     }
61250   }
61251
61252 }
61253
61254
61255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61256   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61257   std::string *arg2 = 0 ;
61258   Dali::Toolkit::Builder::UIFormat arg3 ;
61259
61260   arg1 = (Dali::Toolkit::Builder *)jarg1;
61261   if (!jarg2) {
61262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61263     return ;
61264   }
61265   std::string arg2_str(jarg2);
61266   arg2 = &arg2_str;
61267   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61268   {
61269     try {
61270       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61271     } catch (std::out_of_range& e) {
61272       {
61273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61274       };
61275     } catch (std::exception& e) {
61276       {
61277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61278       };
61279     } catch (Dali::DaliException e) {
61280       {
61281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61282       };
61283     } catch (...) {
61284       {
61285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61286       };
61287     }
61288   }
61289
61290
61291   //argout typemap for const std::string&
61292
61293 }
61294
61295
61296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61297   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61298   std::string *arg2 = 0 ;
61299
61300   arg1 = (Dali::Toolkit::Builder *)jarg1;
61301   if (!jarg2) {
61302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61303     return ;
61304   }
61305   std::string arg2_str(jarg2);
61306   arg2 = &arg2_str;
61307   {
61308     try {
61309       (arg1)->LoadFromString((std::string const &)*arg2);
61310     } catch (std::out_of_range& e) {
61311       {
61312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61313       };
61314     } catch (std::exception& e) {
61315       {
61316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61317       };
61318     } catch (Dali::DaliException e) {
61319       {
61320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61321       };
61322     } catch (...) {
61323       {
61324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61325       };
61326     }
61327   }
61328
61329
61330   //argout typemap for const std::string&
61331
61332 }
61333
61334
61335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61336   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61337   Dali::Property::Map *arg2 = 0 ;
61338
61339   arg1 = (Dali::Toolkit::Builder *)jarg1;
61340   arg2 = (Dali::Property::Map *)jarg2;
61341   if (!arg2) {
61342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61343     return ;
61344   }
61345   {
61346     try {
61347       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61348     } catch (std::out_of_range& e) {
61349       {
61350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61351       };
61352     } catch (std::exception& e) {
61353       {
61354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61355       };
61356     } catch (Dali::DaliException e) {
61357       {
61358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61359       };
61360     } catch (...) {
61361       {
61362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61363       };
61364     }
61365   }
61366
61367 }
61368
61369
61370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61371   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61372   std::string *arg2 = 0 ;
61373   Dali::Property::Value *arg3 = 0 ;
61374
61375   arg1 = (Dali::Toolkit::Builder *)jarg1;
61376   if (!jarg2) {
61377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61378     return ;
61379   }
61380   std::string arg2_str(jarg2);
61381   arg2 = &arg2_str;
61382   arg3 = (Dali::Property::Value *)jarg3;
61383   if (!arg3) {
61384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61385     return ;
61386   }
61387   {
61388     try {
61389       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61390     } catch (std::out_of_range& e) {
61391       {
61392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61393       };
61394     } catch (std::exception& e) {
61395       {
61396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61397       };
61398     } catch (Dali::DaliException e) {
61399       {
61400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61401       };
61402     } catch (...) {
61403       {
61404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61405       };
61406     }
61407   }
61408
61409
61410   //argout typemap for const std::string&
61411
61412 }
61413
61414
61415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61416   void * jresult ;
61417   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61418   Dali::Property::Map *result = 0 ;
61419
61420   arg1 = (Dali::Toolkit::Builder *)jarg1;
61421   {
61422     try {
61423       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61424     } catch (std::out_of_range& e) {
61425       {
61426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61427       };
61428     } catch (std::exception& e) {
61429       {
61430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61431       };
61432     } catch (Dali::DaliException e) {
61433       {
61434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61435       };
61436     } catch (...) {
61437       {
61438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61439       };
61440     }
61441   }
61442
61443   jresult = (void *)result;
61444   return jresult;
61445 }
61446
61447
61448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61449   void * jresult ;
61450   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61451   std::string *arg2 = 0 ;
61452   Dali::Property::Value *result = 0 ;
61453
61454   arg1 = (Dali::Toolkit::Builder *)jarg1;
61455   if (!jarg2) {
61456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61457     return 0;
61458   }
61459   std::string arg2_str(jarg2);
61460   arg2 = &arg2_str;
61461   {
61462     try {
61463       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61464     } catch (std::out_of_range& e) {
61465       {
61466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61467       };
61468     } catch (std::exception& e) {
61469       {
61470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61471       };
61472     } catch (Dali::DaliException e) {
61473       {
61474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61475       };
61476     } catch (...) {
61477       {
61478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61479       };
61480     }
61481   }
61482
61483   jresult = (void *)result;
61484
61485   //argout typemap for const std::string&
61486
61487   return jresult;
61488 }
61489
61490
61491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61492   void * jresult ;
61493   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61494   std::string *arg2 = 0 ;
61495   Dali::Animation result;
61496
61497   arg1 = (Dali::Toolkit::Builder *)jarg1;
61498   if (!jarg2) {
61499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61500     return 0;
61501   }
61502   std::string arg2_str(jarg2);
61503   arg2 = &arg2_str;
61504   {
61505     try {
61506       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61507     } catch (std::out_of_range& e) {
61508       {
61509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61510       };
61511     } catch (std::exception& e) {
61512       {
61513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61514       };
61515     } catch (Dali::DaliException e) {
61516       {
61517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61518       };
61519     } catch (...) {
61520       {
61521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61522       };
61523     }
61524   }
61525
61526   jresult = new Dali::Animation((const Dali::Animation &)result);
61527
61528   //argout typemap for const std::string&
61529
61530   return jresult;
61531 }
61532
61533
61534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61535   void * jresult ;
61536   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61537   std::string *arg2 = 0 ;
61538   Dali::Property::Map *arg3 = 0 ;
61539   Dali::Animation result;
61540
61541   arg1 = (Dali::Toolkit::Builder *)jarg1;
61542   if (!jarg2) {
61543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61544     return 0;
61545   }
61546   std::string arg2_str(jarg2);
61547   arg2 = &arg2_str;
61548   arg3 = (Dali::Property::Map *)jarg3;
61549   if (!arg3) {
61550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61551     return 0;
61552   }
61553   {
61554     try {
61555       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61556     } catch (std::out_of_range& e) {
61557       {
61558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61559       };
61560     } catch (std::exception& e) {
61561       {
61562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61563       };
61564     } catch (Dali::DaliException e) {
61565       {
61566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61567       };
61568     } catch (...) {
61569       {
61570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61571       };
61572     }
61573   }
61574
61575   jresult = new Dali::Animation((const Dali::Animation &)result);
61576
61577   //argout typemap for const std::string&
61578
61579   return jresult;
61580 }
61581
61582
61583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61584   void * jresult ;
61585   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61586   std::string *arg2 = 0 ;
61587   Dali::Actor arg3 ;
61588   Dali::Actor *argp3 ;
61589   Dali::Animation result;
61590
61591   arg1 = (Dali::Toolkit::Builder *)jarg1;
61592   if (!jarg2) {
61593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61594     return 0;
61595   }
61596   std::string arg2_str(jarg2);
61597   arg2 = &arg2_str;
61598   argp3 = (Dali::Actor *)jarg3;
61599   if (!argp3) {
61600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61601     return 0;
61602   }
61603   arg3 = *argp3;
61604   {
61605     try {
61606       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61607     } catch (std::out_of_range& e) {
61608       {
61609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61610       };
61611     } catch (std::exception& e) {
61612       {
61613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61614       };
61615     } catch (Dali::DaliException e) {
61616       {
61617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61618       };
61619     } catch (...) {
61620       {
61621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61622       };
61623     }
61624   }
61625
61626   jresult = new Dali::Animation((const Dali::Animation &)result);
61627
61628   //argout typemap for const std::string&
61629
61630   return jresult;
61631 }
61632
61633
61634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61635   void * jresult ;
61636   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61637   std::string *arg2 = 0 ;
61638   Dali::Property::Map *arg3 = 0 ;
61639   Dali::Actor arg4 ;
61640   Dali::Actor *argp4 ;
61641   Dali::Animation result;
61642
61643   arg1 = (Dali::Toolkit::Builder *)jarg1;
61644   if (!jarg2) {
61645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61646     return 0;
61647   }
61648   std::string arg2_str(jarg2);
61649   arg2 = &arg2_str;
61650   arg3 = (Dali::Property::Map *)jarg3;
61651   if (!arg3) {
61652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61653     return 0;
61654   }
61655   argp4 = (Dali::Actor *)jarg4;
61656   if (!argp4) {
61657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61658     return 0;
61659   }
61660   arg4 = *argp4;
61661   {
61662     try {
61663       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61664     } catch (std::out_of_range& e) {
61665       {
61666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61667       };
61668     } catch (std::exception& e) {
61669       {
61670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61671       };
61672     } catch (Dali::DaliException e) {
61673       {
61674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61675       };
61676     } catch (...) {
61677       {
61678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61679       };
61680     }
61681   }
61682
61683   jresult = new Dali::Animation((const Dali::Animation &)result);
61684
61685   //argout typemap for const std::string&
61686
61687   return jresult;
61688 }
61689
61690
61691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61692   void * jresult ;
61693   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61694   std::string *arg2 = 0 ;
61695   Dali::BaseHandle result;
61696
61697   arg1 = (Dali::Toolkit::Builder *)jarg1;
61698   if (!jarg2) {
61699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61700     return 0;
61701   }
61702   std::string arg2_str(jarg2);
61703   arg2 = &arg2_str;
61704   {
61705     try {
61706       result = (arg1)->Create((std::string const &)*arg2);
61707     } catch (std::out_of_range& e) {
61708       {
61709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61710       };
61711     } catch (std::exception& e) {
61712       {
61713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61714       };
61715     } catch (Dali::DaliException e) {
61716       {
61717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61718       };
61719     } catch (...) {
61720       {
61721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61722       };
61723     }
61724   }
61725
61726   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61727
61728   //argout typemap for const std::string&
61729
61730   return jresult;
61731 }
61732
61733
61734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61735   void * jresult ;
61736   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61737   std::string *arg2 = 0 ;
61738   Dali::Property::Map *arg3 = 0 ;
61739   Dali::BaseHandle result;
61740
61741   arg1 = (Dali::Toolkit::Builder *)jarg1;
61742   if (!jarg2) {
61743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61744     return 0;
61745   }
61746   std::string arg2_str(jarg2);
61747   arg2 = &arg2_str;
61748   arg3 = (Dali::Property::Map *)jarg3;
61749   if (!arg3) {
61750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61751     return 0;
61752   }
61753   {
61754     try {
61755       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61756     } catch (std::out_of_range& e) {
61757       {
61758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61759       };
61760     } catch (std::exception& e) {
61761       {
61762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61763       };
61764     } catch (Dali::DaliException e) {
61765       {
61766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61767       };
61768     } catch (...) {
61769       {
61770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61771       };
61772     }
61773   }
61774
61775   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61776
61777   //argout typemap for const std::string&
61778
61779   return jresult;
61780 }
61781
61782
61783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61784   void * jresult ;
61785   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61786   std::string *arg2 = 0 ;
61787   Dali::BaseHandle result;
61788
61789   arg1 = (Dali::Toolkit::Builder *)jarg1;
61790   if (!jarg2) {
61791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61792     return 0;
61793   }
61794   std::string arg2_str(jarg2);
61795   arg2 = &arg2_str;
61796   {
61797     try {
61798       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61799     } catch (std::out_of_range& e) {
61800       {
61801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61802       };
61803     } catch (std::exception& e) {
61804       {
61805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61806       };
61807     } catch (Dali::DaliException e) {
61808       {
61809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61810       };
61811     } catch (...) {
61812       {
61813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61814       };
61815     }
61816   }
61817
61818   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61819
61820   //argout typemap for const std::string&
61821
61822   return jresult;
61823 }
61824
61825
61826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61827   unsigned int jresult ;
61828   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61829   std::string *arg2 = 0 ;
61830   Dali::Handle *arg3 = 0 ;
61831   bool result;
61832
61833   arg1 = (Dali::Toolkit::Builder *)jarg1;
61834   if (!jarg2) {
61835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61836     return 0;
61837   }
61838   std::string arg2_str(jarg2);
61839   arg2 = &arg2_str;
61840   arg3 = (Dali::Handle *)jarg3;
61841   if (!arg3) {
61842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61843     return 0;
61844   }
61845   {
61846     try {
61847       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
61848     } catch (std::out_of_range& e) {
61849       {
61850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61851       };
61852     } catch (std::exception& e) {
61853       {
61854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61855       };
61856     } catch (Dali::DaliException e) {
61857       {
61858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61859       };
61860     } catch (...) {
61861       {
61862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61863       };
61864     }
61865   }
61866
61867   jresult = result;
61868
61869   //argout typemap for const std::string&
61870
61871   return jresult;
61872 }
61873
61874
61875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
61876   unsigned int jresult ;
61877   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61878   Dali::Handle *arg2 = 0 ;
61879   std::string *arg3 = 0 ;
61880   bool result;
61881
61882   arg1 = (Dali::Toolkit::Builder *)jarg1;
61883   arg2 = (Dali::Handle *)jarg2;
61884   if (!arg2) {
61885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61886     return 0;
61887   }
61888   if (!jarg3) {
61889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61890     return 0;
61891   }
61892   std::string arg3_str(jarg3);
61893   arg3 = &arg3_str;
61894   {
61895     try {
61896       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
61897     } catch (std::out_of_range& e) {
61898       {
61899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61900       };
61901     } catch (std::exception& e) {
61902       {
61903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61904       };
61905     } catch (Dali::DaliException e) {
61906       {
61907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61908       };
61909     } catch (...) {
61910       {
61911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61912       };
61913     }
61914   }
61915
61916   jresult = result;
61917
61918   //argout typemap for const std::string&
61919
61920   return jresult;
61921 }
61922
61923
61924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
61925   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61926   Dali::Actor arg2 ;
61927   Dali::Actor *argp2 ;
61928
61929   arg1 = (Dali::Toolkit::Builder *)jarg1;
61930   argp2 = (Dali::Actor *)jarg2;
61931   if (!argp2) {
61932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61933     return ;
61934   }
61935   arg2 = *argp2;
61936   {
61937     try {
61938       (arg1)->AddActors(arg2);
61939     } catch (std::out_of_range& e) {
61940       {
61941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61942       };
61943     } catch (std::exception& e) {
61944       {
61945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61946       };
61947     } catch (Dali::DaliException e) {
61948       {
61949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61950       };
61951     } catch (...) {
61952       {
61953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61954       };
61955     }
61956   }
61957
61958 }
61959
61960
61961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61962   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61963   std::string *arg2 = 0 ;
61964   Dali::Actor arg3 ;
61965   Dali::Actor *argp3 ;
61966
61967   arg1 = (Dali::Toolkit::Builder *)jarg1;
61968   if (!jarg2) {
61969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61970     return ;
61971   }
61972   std::string arg2_str(jarg2);
61973   arg2 = &arg2_str;
61974   argp3 = (Dali::Actor *)jarg3;
61975   if (!argp3) {
61976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61977     return ;
61978   }
61979   arg3 = *argp3;
61980   {
61981     try {
61982       (arg1)->AddActors((std::string const &)*arg2,arg3);
61983     } catch (std::out_of_range& e) {
61984       {
61985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61986       };
61987     } catch (std::exception& e) {
61988       {
61989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61990       };
61991     } catch (Dali::DaliException e) {
61992       {
61993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61994       };
61995     } catch (...) {
61996       {
61997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61998       };
61999     }
62000   }
62001
62002
62003   //argout typemap for const std::string&
62004
62005 }
62006
62007
62008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62009   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62010   std::string *arg2 = 0 ;
62011
62012   arg1 = (Dali::Toolkit::Builder *)jarg1;
62013   if (!jarg2) {
62014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62015     return ;
62016   }
62017   std::string arg2_str(jarg2);
62018   arg2 = &arg2_str;
62019   {
62020     try {
62021       (arg1)->CreateRenderTask((std::string const &)*arg2);
62022     } catch (std::out_of_range& e) {
62023       {
62024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62025       };
62026     } catch (std::exception& e) {
62027       {
62028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62029       };
62030     } catch (Dali::DaliException e) {
62031       {
62032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62033       };
62034     } catch (...) {
62035       {
62036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62037       };
62038     }
62039   }
62040
62041
62042   //argout typemap for const std::string&
62043
62044 }
62045
62046
62047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62048   void * jresult ;
62049   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62050   std::string *arg2 = 0 ;
62051   Dali::Path result;
62052
62053   arg1 = (Dali::Toolkit::Builder *)jarg1;
62054   if (!jarg2) {
62055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62056     return 0;
62057   }
62058   std::string arg2_str(jarg2);
62059   arg2 = &arg2_str;
62060   {
62061     try {
62062       result = (arg1)->GetPath((std::string const &)*arg2);
62063     } catch (std::out_of_range& e) {
62064       {
62065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62066       };
62067     } catch (std::exception& e) {
62068       {
62069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62070       };
62071     } catch (Dali::DaliException e) {
62072       {
62073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62074       };
62075     } catch (...) {
62076       {
62077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62078       };
62079     }
62080   }
62081
62082   jresult = new Dali::Path((const Dali::Path &)result);
62083
62084   //argout typemap for const std::string&
62085
62086   return jresult;
62087 }
62088
62089
62090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62091   void * jresult ;
62092   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62093   std::string *arg2 = 0 ;
62094   Dali::PathConstrainer result;
62095
62096   arg1 = (Dali::Toolkit::Builder *)jarg1;
62097   if (!jarg2) {
62098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62099     return 0;
62100   }
62101   std::string arg2_str(jarg2);
62102   arg2 = &arg2_str;
62103   {
62104     try {
62105       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62106     } catch (std::out_of_range& e) {
62107       {
62108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62109       };
62110     } catch (std::exception& e) {
62111       {
62112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62113       };
62114     } catch (Dali::DaliException e) {
62115       {
62116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62117       };
62118     } catch (...) {
62119       {
62120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62121       };
62122     }
62123   }
62124
62125   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62126
62127   //argout typemap for const std::string&
62128
62129   return jresult;
62130 }
62131
62132
62133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62134   void * jresult ;
62135   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62136   std::string *arg2 = 0 ;
62137   Dali::LinearConstrainer result;
62138
62139   arg1 = (Dali::Toolkit::Builder *)jarg1;
62140   if (!jarg2) {
62141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62142     return 0;
62143   }
62144   std::string arg2_str(jarg2);
62145   arg2 = &arg2_str;
62146   {
62147     try {
62148       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62149     } catch (std::out_of_range& e) {
62150       {
62151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62152       };
62153     } catch (std::exception& e) {
62154       {
62155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62156       };
62157     } catch (Dali::DaliException e) {
62158       {
62159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62160       };
62161     } catch (...) {
62162       {
62163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62164       };
62165     }
62166   }
62167
62168   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62169
62170   //argout typemap for const std::string&
62171
62172   return jresult;
62173 }
62174
62175
62176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62177   void * jresult ;
62178   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62179   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62180
62181   arg1 = (Dali::Toolkit::Builder *)jarg1;
62182   {
62183     try {
62184       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62185     } catch (std::out_of_range& e) {
62186       {
62187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62188       };
62189     } catch (std::exception& e) {
62190       {
62191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62192       };
62193     } catch (Dali::DaliException e) {
62194       {
62195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62196       };
62197     } catch (...) {
62198       {
62199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62200       };
62201     }
62202   }
62203
62204   jresult = (void *)result;
62205   return jresult;
62206 }
62207
62208
62209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62210   void * jresult ;
62211   Dali::Toolkit::TransitionData *result = 0 ;
62212
62213   {
62214     try {
62215       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62216     } catch (std::out_of_range& e) {
62217       {
62218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62219       };
62220     } catch (std::exception& e) {
62221       {
62222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62223       };
62224     } catch (Dali::DaliException e) {
62225       {
62226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62227       };
62228     } catch (...) {
62229       {
62230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62231       };
62232     }
62233   }
62234
62235   jresult = (void *)result;
62236   return jresult;
62237 }
62238
62239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62240   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62241
62242   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62243   {
62244     try {
62245       delete arg1;
62246     } catch (std::out_of_range& e) {
62247       {
62248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62249       };
62250     } catch (std::exception& e) {
62251       {
62252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62253       };
62254     } catch (Dali::DaliException e) {
62255       {
62256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62257       };
62258     } catch (...) {
62259       {
62260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62261       };
62262     }
62263   }
62264
62265 }
62266
62267
62268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62269   void * jresult ;
62270   Dali::Property::Map *arg1 = 0 ;
62271   Dali::Toolkit::TransitionData result;
62272
62273   arg1 = (Dali::Property::Map *)jarg1;
62274   if (!arg1) {
62275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62276     return 0;
62277   }
62278   {
62279     try {
62280       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62281     } catch (std::out_of_range& e) {
62282       {
62283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62284       };
62285     } catch (std::exception& e) {
62286       {
62287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62288       };
62289     } catch (Dali::DaliException e) {
62290       {
62291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62292       };
62293     } catch (...) {
62294       {
62295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62296       };
62297     }
62298   }
62299
62300   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62301   return jresult;
62302 }
62303
62304
62305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62306   void * jresult ;
62307   Dali::Property::Array *arg1 = 0 ;
62308   Dali::Toolkit::TransitionData result;
62309
62310   arg1 = (Dali::Property::Array *)jarg1;
62311   if (!arg1) {
62312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62313     return 0;
62314   }
62315   {
62316     try {
62317       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62318     } catch (std::out_of_range& e) {
62319       {
62320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62321       };
62322     } catch (std::exception& e) {
62323       {
62324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62325       };
62326     } catch (Dali::DaliException e) {
62327       {
62328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62329       };
62330     } catch (...) {
62331       {
62332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62333       };
62334     }
62335   }
62336
62337   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62338   return jresult;
62339 }
62340
62341
62342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62343   void * jresult ;
62344   Dali::BaseHandle arg1 ;
62345   Dali::BaseHandle *argp1 ;
62346   Dali::Toolkit::TransitionData result;
62347
62348   argp1 = (Dali::BaseHandle *)jarg1;
62349   if (!argp1) {
62350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62351     return 0;
62352   }
62353   arg1 = *argp1;
62354   {
62355     try {
62356       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62357     } catch (std::out_of_range& e) {
62358       {
62359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62360       };
62361     } catch (std::exception& e) {
62362       {
62363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62364       };
62365     } catch (Dali::DaliException e) {
62366       {
62367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62368       };
62369     } catch (...) {
62370       {
62371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62372       };
62373     }
62374   }
62375
62376   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62377   return jresult;
62378 }
62379
62380
62381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62382   void * jresult ;
62383   Dali::Toolkit::TransitionData *arg1 = 0 ;
62384   Dali::Toolkit::TransitionData *result = 0 ;
62385
62386   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62387   if (!arg1) {
62388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62389     return 0;
62390   }
62391   {
62392     try {
62393       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62394     } catch (std::out_of_range& e) {
62395       {
62396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62397       };
62398     } catch (std::exception& e) {
62399       {
62400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62401       };
62402     } catch (Dali::DaliException e) {
62403       {
62404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62405       };
62406     } catch (...) {
62407       {
62408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62409       };
62410     }
62411   }
62412
62413   jresult = (void *)result;
62414   return jresult;
62415 }
62416
62417
62418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62419   void * jresult ;
62420   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62421   Dali::Toolkit::TransitionData *arg2 = 0 ;
62422   Dali::Toolkit::TransitionData *result = 0 ;
62423
62424   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62425   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62426   if (!arg2) {
62427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62428     return 0;
62429   }
62430   {
62431     try {
62432       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62433     } catch (std::out_of_range& e) {
62434       {
62435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62436       };
62437     } catch (std::exception& e) {
62438       {
62439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62440       };
62441     } catch (Dali::DaliException e) {
62442       {
62443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62444       };
62445     } catch (...) {
62446       {
62447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62448       };
62449     }
62450   }
62451
62452   jresult = (void *)result;
62453   return jresult;
62454 }
62455
62456
62457 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62458   unsigned long jresult ;
62459   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62460   size_t result;
62461
62462   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62463   {
62464     try {
62465       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62466     } catch (std::out_of_range& e) {
62467       {
62468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62469       };
62470     } catch (std::exception& e) {
62471       {
62472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62473       };
62474     } catch (Dali::DaliException e) {
62475       {
62476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62477       };
62478     } catch (...) {
62479       {
62480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62481       };
62482     }
62483   }
62484
62485   jresult = (unsigned long)result;
62486   return jresult;
62487 }
62488
62489
62490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62491   void * jresult ;
62492   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62493   size_t arg2 ;
62494   Dali::Property::Map result;
62495
62496   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62497   arg2 = (size_t)jarg2;
62498   {
62499     try {
62500       result = (arg1)->GetAnimatorAt(arg2);
62501     } catch (std::out_of_range& e) {
62502       {
62503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62504       };
62505     } catch (std::exception& e) {
62506       {
62507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62508       };
62509     } catch (Dali::DaliException e) {
62510       {
62511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62512       };
62513     } catch (...) {
62514       {
62515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62516       };
62517     }
62518   }
62519
62520   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62521   return jresult;
62522 }
62523
62524
62525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62526   int jresult ;
62527   int result;
62528
62529   {
62530     try {
62531       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62532     } catch (std::out_of_range& e) {
62533       {
62534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62535       };
62536     } catch (std::exception& e) {
62537       {
62538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62539       };
62540     } catch (Dali::DaliException e) {
62541       {
62542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62543       };
62544     } catch (...) {
62545       {
62546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62547       };
62548     }
62549   }
62550
62551   jresult = (int)result;
62552   return jresult;
62553 }
62554
62555
62556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62557   int jresult ;
62558   int result;
62559
62560   {
62561     try {
62562       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62563     } catch (std::out_of_range& e) {
62564       {
62565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62566       };
62567     } catch (std::exception& e) {
62568       {
62569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62570       };
62571     } catch (Dali::DaliException e) {
62572       {
62573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62574       };
62575     } catch (...) {
62576       {
62577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62578       };
62579     }
62580   }
62581
62582   jresult = (int)result;
62583   return jresult;
62584 }
62585
62586
62587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62588   int jresult ;
62589   int result;
62590
62591   {
62592     try {
62593       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62594     } catch (std::out_of_range& e) {
62595       {
62596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62597       };
62598     } catch (std::exception& e) {
62599       {
62600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62601       };
62602     } catch (Dali::DaliException e) {
62603       {
62604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62605       };
62606     } catch (...) {
62607       {
62608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62609       };
62610     }
62611   }
62612
62613   jresult = (int)result;
62614   return jresult;
62615 }
62616
62617
62618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62619   int jresult ;
62620   int result;
62621
62622   {
62623     try {
62624       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62625     } catch (std::out_of_range& e) {
62626       {
62627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62628       };
62629     } catch (std::exception& e) {
62630       {
62631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62632       };
62633     } catch (Dali::DaliException e) {
62634       {
62635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62636       };
62637     } catch (...) {
62638       {
62639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62640       };
62641     }
62642   }
62643
62644   jresult = (int)result;
62645   return jresult;
62646 }
62647
62648
62649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62650   int jresult ;
62651   int result;
62652
62653   {
62654     try {
62655       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62656     } catch (std::out_of_range& e) {
62657       {
62658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62659       };
62660     } catch (std::exception& e) {
62661       {
62662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62663       };
62664     } catch (Dali::DaliException e) {
62665       {
62666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62667       };
62668     } catch (...) {
62669       {
62670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62671       };
62672     }
62673   }
62674
62675   jresult = (int)result;
62676   return jresult;
62677 }
62678
62679
62680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62681   int jresult ;
62682   int result;
62683
62684   {
62685     try {
62686       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62687     } catch (std::out_of_range& e) {
62688       {
62689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62690       };
62691     } catch (std::exception& e) {
62692       {
62693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62694       };
62695     } catch (Dali::DaliException e) {
62696       {
62697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62698       };
62699     } catch (...) {
62700       {
62701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62702       };
62703     }
62704   }
62705
62706   jresult = (int)result;
62707   return jresult;
62708 }
62709
62710
62711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62712   int jresult ;
62713   int result;
62714
62715   {
62716     try {
62717       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62718     } catch (std::out_of_range& e) {
62719       {
62720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62721       };
62722     } catch (std::exception& e) {
62723       {
62724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62725       };
62726     } catch (Dali::DaliException e) {
62727       {
62728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62729       };
62730     } catch (...) {
62731       {
62732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62733       };
62734     }
62735   }
62736
62737   jresult = (int)result;
62738   return jresult;
62739 }
62740
62741
62742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62743   int jresult ;
62744   int result;
62745
62746   {
62747     try {
62748       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62749     } catch (std::out_of_range& e) {
62750       {
62751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62752       };
62753     } catch (std::exception& e) {
62754       {
62755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62756       };
62757     } catch (Dali::DaliException e) {
62758       {
62759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62760       };
62761     } catch (...) {
62762       {
62763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62764       };
62765     }
62766   }
62767
62768   jresult = (int)result;
62769   return jresult;
62770 }
62771
62772
62773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62774   int jresult ;
62775   int result;
62776
62777   {
62778     try {
62779       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62780     } catch (std::out_of_range& e) {
62781       {
62782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62783       };
62784     } catch (std::exception& e) {
62785       {
62786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62787       };
62788     } catch (Dali::DaliException e) {
62789       {
62790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62791       };
62792     } catch (...) {
62793       {
62794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62795       };
62796     }
62797   }
62798
62799   jresult = (int)result;
62800   return jresult;
62801 }
62802
62803
62804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
62805   int jresult ;
62806   int result;
62807
62808   {
62809     try {
62810       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
62811     } catch (std::out_of_range& e) {
62812       {
62813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62814       };
62815     } catch (std::exception& e) {
62816       {
62817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62818       };
62819     } catch (Dali::DaliException e) {
62820       {
62821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62822       };
62823     } catch (...) {
62824       {
62825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62826       };
62827     }
62828   }
62829
62830   jresult = (int)result;
62831   return jresult;
62832 }
62833
62834
62835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
62836   int jresult ;
62837   int result;
62838
62839   {
62840     try {
62841       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
62842     } catch (std::out_of_range& e) {
62843       {
62844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62845       };
62846     } catch (std::exception& e) {
62847       {
62848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62849       };
62850     } catch (Dali::DaliException e) {
62851       {
62852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62853       };
62854     } catch (...) {
62855       {
62856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62857       };
62858     }
62859   }
62860
62861   jresult = (int)result;
62862   return jresult;
62863 }
62864
62865
62866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
62867   int jresult ;
62868   int result;
62869
62870   {
62871     try {
62872       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
62873     } catch (std::out_of_range& e) {
62874       {
62875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62876       };
62877     } catch (std::exception& e) {
62878       {
62879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62880       };
62881     } catch (Dali::DaliException e) {
62882       {
62883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62884       };
62885     } catch (...) {
62886       {
62887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62888       };
62889     }
62890   }
62891
62892   jresult = (int)result;
62893   return jresult;
62894 }
62895
62896
62897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
62898   int jresult ;
62899   int result;
62900
62901   {
62902     try {
62903       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
62904     } catch (std::out_of_range& e) {
62905       {
62906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62907       };
62908     } catch (std::exception& e) {
62909       {
62910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62911       };
62912     } catch (Dali::DaliException e) {
62913       {
62914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62915       };
62916     } catch (...) {
62917       {
62918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62919       };
62920     }
62921   }
62922
62923   jresult = (int)result;
62924   return jresult;
62925 }
62926
62927
62928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
62929   int jresult ;
62930   int result;
62931
62932   {
62933     try {
62934       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
62935     } catch (std::out_of_range& e) {
62936       {
62937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62938       };
62939     } catch (std::exception& e) {
62940       {
62941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62942       };
62943     } catch (Dali::DaliException e) {
62944       {
62945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62946       };
62947     } catch (...) {
62948       {
62949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62950       };
62951     }
62952   }
62953
62954   jresult = (int)result;
62955   return jresult;
62956 }
62957
62958
62959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
62960   void * jresult ;
62961   Dali::Toolkit::Control result;
62962
62963   {
62964     try {
62965       result = Dali::Toolkit::Internal::Control::New();
62966     } catch (std::out_of_range& e) {
62967       {
62968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62969       };
62970     } catch (std::exception& e) {
62971       {
62972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62973       };
62974     } catch (Dali::DaliException e) {
62975       {
62976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62977       };
62978     } catch (...) {
62979       {
62980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62981       };
62982     }
62983   }
62984
62985   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62986   return jresult;
62987 }
62988
62989
62990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
62991   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62992   std::string *arg2 = 0 ;
62993
62994   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62995   if (!jarg2) {
62996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62997     return ;
62998   }
62999   std::string arg2_str(jarg2);
63000   arg2 = &arg2_str;
63001   {
63002     try {
63003       (arg1)->SetStyleName((std::string const &)*arg2);
63004     } catch (std::out_of_range& e) {
63005       {
63006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63007       };
63008     } catch (std::exception& e) {
63009       {
63010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63011       };
63012     } catch (Dali::DaliException e) {
63013       {
63014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63015       };
63016     } catch (...) {
63017       {
63018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63019       };
63020     }
63021   }
63022
63023
63024   //argout typemap for const std::string&
63025
63026 }
63027
63028
63029 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63030   char * jresult ;
63031   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63032   std::string *result = 0 ;
63033
63034   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63035   {
63036     try {
63037       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63038     } catch (std::out_of_range& e) {
63039       {
63040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63041       };
63042     } catch (std::exception& e) {
63043       {
63044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63045       };
63046     } catch (Dali::DaliException e) {
63047       {
63048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63049       };
63050     } catch (...) {
63051       {
63052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63053       };
63054     }
63055   }
63056
63057   jresult = SWIG_csharp_string_callback(result->c_str());
63058   return jresult;
63059 }
63060
63061
63062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63063   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63064   Dali::Vector4 *arg2 = 0 ;
63065
63066   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63067   arg2 = (Dali::Vector4 *)jarg2;
63068   if (!arg2) {
63069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63070     return ;
63071   }
63072   {
63073     try {
63074       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63075     } catch (std::out_of_range& e) {
63076       {
63077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63078       };
63079     } catch (std::exception& e) {
63080       {
63081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63082       };
63083     } catch (Dali::DaliException e) {
63084       {
63085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63086       };
63087     } catch (...) {
63088       {
63089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63090       };
63091     }
63092   }
63093
63094 }
63095
63096
63097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63098   void * jresult ;
63099   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
63100   Dali::Vector4 result;
63101
63102   arg1 = (Dali::Handle *)jarg1;
63103   {
63104     try {
63105       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
63106       if (resultMap)
63107       {
63108         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
63109         if(type && type->Get<int>() == Visual::COLOR )
63110         {
63111           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
63112           if (value)
63113           {
63114             result = value->Get<Vector4>();
63115           }
63116         }
63117       }
63118     } catch (std::out_of_range& e) {
63119       {
63120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63121       };
63122     } catch (std::exception& e) {
63123       {
63124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63125       };
63126     } catch (Dali::DaliException e) {
63127       {
63128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63129       };
63130     } catch (...) {
63131       {
63132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63133       };
63134     }
63135   }
63136
63137   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63138   return jresult;
63139 }
63140
63141
63142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63143   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63144   Dali::Property::Map *arg2 = 0 ;
63145
63146   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63147   arg2 = (Dali::Property::Map *)jarg2;
63148   if (!arg2) {
63149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63150     return ;
63151   }
63152   {
63153     try {
63154       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63155     } catch (std::out_of_range& e) {
63156       {
63157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63158       };
63159     } catch (std::exception& e) {
63160       {
63161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63162       };
63163     } catch (Dali::DaliException e) {
63164       {
63165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63166       };
63167     } catch (...) {
63168       {
63169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63170       };
63171     }
63172   }
63173
63174 }
63175
63176
63177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63179
63180   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63181   {
63182     try {
63183       (arg1)->ClearBackground();
63184     } catch (std::out_of_range& e) {
63185       {
63186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63187       };
63188     } catch (std::exception& e) {
63189       {
63190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63191       };
63192     } catch (Dali::DaliException e) {
63193       {
63194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63195       };
63196     } catch (...) {
63197       {
63198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63199       };
63200     }
63201   }
63202
63203 }
63204
63205
63206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63207   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63208   Dali::Gesture::Type arg2 ;
63209
63210   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63211   arg2 = (Dali::Gesture::Type)jarg2;
63212   {
63213     try {
63214       (arg1)->EnableGestureDetection(arg2);
63215     } catch (std::out_of_range& e) {
63216       {
63217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63218       };
63219     } catch (std::exception& e) {
63220       {
63221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63222       };
63223     } catch (Dali::DaliException e) {
63224       {
63225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63226       };
63227     } catch (...) {
63228       {
63229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63230       };
63231     }
63232   }
63233
63234 }
63235
63236
63237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63238   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63239   Dali::Gesture::Type arg2 ;
63240
63241   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63242   arg2 = (Dali::Gesture::Type)jarg2;
63243   {
63244     try {
63245       (arg1)->DisableGestureDetection(arg2);
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_GetPinchGestureDetector(void * jarg1) {
63269   void * jresult ;
63270   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63271   Dali::PinchGestureDetector result;
63272
63273   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63274   {
63275     try {
63276       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63277     } catch (std::out_of_range& e) {
63278       {
63279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63280       };
63281     } catch (std::exception& e) {
63282       {
63283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63284       };
63285     } catch (Dali::DaliException e) {
63286       {
63287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63288       };
63289     } catch (...) {
63290       {
63291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63292       };
63293     }
63294   }
63295
63296   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63297   return jresult;
63298 }
63299
63300
63301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63302   void * jresult ;
63303   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63304   Dali::PanGestureDetector result;
63305
63306   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63307   {
63308     try {
63309       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63310     } catch (std::out_of_range& e) {
63311       {
63312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63313       };
63314     } catch (std::exception& e) {
63315       {
63316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63317       };
63318     } catch (Dali::DaliException e) {
63319       {
63320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63321       };
63322     } catch (...) {
63323       {
63324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63325       };
63326     }
63327   }
63328
63329   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63330   return jresult;
63331 }
63332
63333
63334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63335   void * jresult ;
63336   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63337   Dali::TapGestureDetector result;
63338
63339   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63340   {
63341     try {
63342       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63343     } catch (std::out_of_range& e) {
63344       {
63345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63346       };
63347     } catch (std::exception& e) {
63348       {
63349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63350       };
63351     } catch (Dali::DaliException e) {
63352       {
63353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63354       };
63355     } catch (...) {
63356       {
63357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63358       };
63359     }
63360   }
63361
63362   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63363   return jresult;
63364 }
63365
63366
63367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63368   void * jresult ;
63369   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63370   Dali::LongPressGestureDetector result;
63371
63372   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63373   {
63374     try {
63375       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63376     } catch (std::out_of_range& e) {
63377       {
63378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63379       };
63380     } catch (std::exception& e) {
63381       {
63382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63383       };
63384     } catch (Dali::DaliException e) {
63385       {
63386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63387       };
63388     } catch (...) {
63389       {
63390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63391       };
63392     }
63393   }
63394
63395   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63396   return jresult;
63397 }
63398
63399
63400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63401   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63402   bool arg2 ;
63403
63404   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63405   arg2 = jarg2 ? true : false;
63406   {
63407     try {
63408       (arg1)->SetKeyboardNavigationSupport(arg2);
63409     } catch (std::out_of_range& e) {
63410       {
63411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63412       };
63413     } catch (std::exception& e) {
63414       {
63415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63416       };
63417     } catch (Dali::DaliException e) {
63418       {
63419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63420       };
63421     } catch (...) {
63422       {
63423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63424       };
63425     }
63426   }
63427
63428 }
63429
63430
63431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63432   unsigned int jresult ;
63433   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63434   bool result;
63435
63436   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63437   {
63438     try {
63439       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63440     } catch (std::out_of_range& e) {
63441       {
63442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63443       };
63444     } catch (std::exception& e) {
63445       {
63446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63447       };
63448     } catch (Dali::DaliException e) {
63449       {
63450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63451       };
63452     } catch (...) {
63453       {
63454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63455       };
63456     }
63457   }
63458
63459   jresult = result;
63460   return jresult;
63461 }
63462
63463
63464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63465   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63466
63467   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63468   {
63469     try {
63470       (arg1)->SetKeyInputFocus();
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_HasKeyInputFocus(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)->HasKeyInputFocus();
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_ClearKeyInputFocus(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)->ClearKeyInputFocus();
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 void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63556   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63557   bool arg2 ;
63558
63559   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63560   arg2 = jarg2 ? true : false;
63561   {
63562     try {
63563       (arg1)->SetAsKeyboardFocusGroup(arg2);
63564     } catch (std::out_of_range& e) {
63565       {
63566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63567       };
63568     } catch (std::exception& e) {
63569       {
63570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63571       };
63572     } catch (Dali::DaliException e) {
63573       {
63574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63575       };
63576     } catch (...) {
63577       {
63578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63579       };
63580     }
63581   }
63582
63583 }
63584
63585
63586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63587   unsigned int jresult ;
63588   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63589   bool result;
63590
63591   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63592   {
63593     try {
63594       result = (bool)(arg1)->IsKeyboardFocusGroup();
63595     } catch (std::out_of_range& e) {
63596       {
63597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63598       };
63599     } catch (std::exception& e) {
63600       {
63601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63602       };
63603     } catch (Dali::DaliException e) {
63604       {
63605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63606       };
63607     } catch (...) {
63608       {
63609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63610       };
63611     }
63612   }
63613
63614   jresult = result;
63615   return jresult;
63616 }
63617
63618
63619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63620   void * jresult ;
63621   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63622   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63623
63624   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63625   {
63626     try {
63627       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63628     } catch (std::out_of_range& e) {
63629       {
63630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63631       };
63632     } catch (std::exception& e) {
63633       {
63634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63635       };
63636     } catch (Dali::DaliException e) {
63637       {
63638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63639       };
63640     } catch (...) {
63641       {
63642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63643       };
63644     }
63645   }
63646
63647   jresult = (void *)result;
63648   return jresult;
63649 }
63650
63651
63652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63653   void * jresult ;
63654   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63655   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63656
63657   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63658   {
63659     try {
63660       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63661     } catch (std::out_of_range& e) {
63662       {
63663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63664       };
63665     } catch (std::exception& e) {
63666       {
63667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63668       };
63669     } catch (Dali::DaliException e) {
63670       {
63671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63672       };
63673     } catch (...) {
63674       {
63675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63676       };
63677     }
63678   }
63679
63680   jresult = (void *)result;
63681   return jresult;
63682 }
63683
63684
63685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63686   void * jresult ;
63687   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63688   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63689
63690   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63691   {
63692     try {
63693       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63694     } catch (std::out_of_range& e) {
63695       {
63696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63697       };
63698     } catch (std::exception& e) {
63699       {
63700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63701       };
63702     } catch (Dali::DaliException e) {
63703       {
63704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63705       };
63706     } catch (...) {
63707       {
63708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63709       };
63710     }
63711   }
63712
63713   jresult = (void *)result;
63714   return jresult;
63715 }
63716
63717
63718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63719   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63720   int arg2 ;
63721   SwigDirector_ViewImpl *darg = 0;
63722
63723   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63724   arg2 = (int)jarg2;
63725   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63726   if(!darg) {
63727     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63728     return;
63729   }
63730   {
63731     try {
63732       if(darg) {
63733         (darg)->OnStageConnection(arg2);
63734       }
63735     } catch (std::out_of_range& e) {
63736       {
63737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63738       };
63739     } catch (std::exception& e) {
63740       {
63741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63742       };
63743     } catch (Dali::DaliException e) {
63744       {
63745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63746       };
63747     } catch (...) {
63748       {
63749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63750       };
63751     }
63752   }
63753
63754 }
63755
63756
63757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63758   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63759   int arg2 ;
63760   SwigDirector_ViewImpl *darg = 0;
63761
63762   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63763   arg2 = (int)jarg2;
63764   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63765   if(!darg) {
63766     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63767     return;
63768   }
63769   {
63770     try {
63771       if(darg) {
63772         (darg)->OnStageConnectionSwigPublic(arg2);
63773       }
63774     } catch (std::out_of_range& e) {
63775       {
63776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63777       };
63778     } catch (std::exception& e) {
63779       {
63780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63781       };
63782     } catch (Dali::DaliException e) {
63783       {
63784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63785       };
63786     } catch (...) {
63787       {
63788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63789       };
63790     }
63791   }
63792
63793 }
63794
63795
63796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
63797   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63798   SwigDirector_ViewImpl *darg = 0;
63799
63800   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63801   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63802   if(!darg) {
63803     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63804     return;
63805   }
63806   {
63807     try {
63808       if(darg) {
63809         (darg)->OnStageDisconnection();
63810       }
63811     } catch (std::out_of_range& e) {
63812       {
63813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63814       };
63815     } catch (std::exception& e) {
63816       {
63817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63818       };
63819     } catch (Dali::DaliException e) {
63820       {
63821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63822       };
63823     } catch (...) {
63824       {
63825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63826       };
63827     }
63828   }
63829
63830 }
63831
63832
63833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
63834   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63835   SwigDirector_ViewImpl *darg = 0;
63836
63837   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63838   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63839   if(!darg) {
63840     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63841     return;
63842   }
63843   {
63844     try {
63845       if(darg) {
63846         (darg)->OnStageDisconnectionSwigPublic();
63847       }
63848     } catch (std::out_of_range& e) {
63849       {
63850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63851       };
63852     } catch (std::exception& e) {
63853       {
63854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63855       };
63856     } catch (Dali::DaliException e) {
63857       {
63858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63859       };
63860     } catch (...) {
63861       {
63862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63863       };
63864     }
63865   }
63866
63867 }
63868
63869
63870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
63871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63872   Dali::Actor *arg2 = 0 ;
63873   SwigDirector_ViewImpl *darg = 0;
63874
63875   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63876   arg2 = (Dali::Actor *)jarg2;
63877   if (!arg2) {
63878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63879     return ;
63880   }
63881   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63882   if(!darg) {
63883     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63884     return;
63885   }
63886   {
63887     try {
63888       if(darg) {
63889         (darg)->OnChildAdd(*arg2);
63890       }
63891     } catch (std::out_of_range& e) {
63892       {
63893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63894       };
63895     } catch (std::exception& e) {
63896       {
63897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63898       };
63899     } catch (Dali::DaliException e) {
63900       {
63901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63902       };
63903     } catch (...) {
63904       {
63905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63906       };
63907     }
63908   }
63909
63910 }
63911
63912
63913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63914   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63915   Dali::Actor *arg2 = 0 ;
63916   SwigDirector_ViewImpl *darg = 0;
63917
63918   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63919   arg2 = (Dali::Actor *)jarg2;
63920   if (!arg2) {
63921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63922     return ;
63923   }
63924   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63925   if(!darg) {
63926     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63927     return;
63928   }
63929   {
63930     try {
63931       if(darg) {
63932           (darg)->OnChildAddSwigPublic(*arg2);
63933       }
63934     } catch (std::out_of_range& e) {
63935       {
63936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63937       };
63938     } catch (std::exception& e) {
63939       {
63940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63941       };
63942     } catch (Dali::DaliException e) {
63943       {
63944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63945       };
63946     } catch (...) {
63947       {
63948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63949       };
63950     }
63951   }
63952
63953 }
63954
63955
63956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
63957   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63958   Dali::Actor *arg2 = 0 ;
63959   SwigDirector_ViewImpl *darg = 0;
63960
63961   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63962   arg2 = (Dali::Actor *)jarg2;
63963   if (!arg2) {
63964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63965     return ;
63966   }
63967   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63968   if(!darg) {
63969     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63970     return;
63971   }
63972   {
63973     try {
63974       if(darg) {
63975         (darg)->OnChildRemove(*arg2);
63976       }
63977     } catch (std::out_of_range& e) {
63978       {
63979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63980       };
63981     } catch (std::exception& e) {
63982       {
63983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63984       };
63985     } catch (Dali::DaliException e) {
63986       {
63987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63988       };
63989     } catch (...) {
63990       {
63991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63992       };
63993     }
63994   }
63995
63996 }
63997
63998
63999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64000   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64001   Dali::Actor *arg2 = 0 ;
64002   SwigDirector_ViewImpl *darg = 0;
64003
64004   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64005   arg2 = (Dali::Actor *)jarg2;
64006   if (!arg2) {
64007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64008     return ;
64009   }
64010   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64011   if(!darg) {
64012     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64013     return;
64014   }
64015   {
64016     try {
64017       if(darg) {
64018         (darg)->OnChildRemoveSwigPublic(*arg2);
64019       }
64020     } catch (std::out_of_range& e) {
64021       {
64022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64023       };
64024     } catch (std::exception& e) {
64025       {
64026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64027       };
64028     } catch (Dali::DaliException e) {
64029       {
64030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64031       };
64032     } catch (...) {
64033       {
64034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64035       };
64036     }
64037   }
64038
64039 }
64040
64041
64042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64043   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64044   Dali::Property::Index arg2 ;
64045   Dali::Property::Value arg3 ;
64046   Dali::Property::Value *argp3 ;
64047   SwigDirector_ViewImpl *darg = 0;
64048
64049   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64050   arg2 = (Dali::Property::Index)jarg2;
64051   argp3 = (Dali::Property::Value *)jarg3;
64052   if (!argp3) {
64053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64054     return ;
64055   }
64056   arg3 = *argp3;
64057   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64058   if (!darg) {
64059     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64060     return;
64061   }
64062   {
64063     try {
64064       (darg)->OnPropertySet(arg2,arg3);
64065     } catch (std::out_of_range& e) {
64066       {
64067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64068       };
64069     } catch (std::exception& e) {
64070       {
64071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64072       };
64073     } catch (Dali::DaliException e) {
64074       {
64075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64076       };
64077     } catch (...) {
64078       {
64079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64080       };
64081     }
64082   }
64083
64084 }
64085
64086
64087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64088   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64089   Dali::Property::Index arg2 ;
64090   Dali::Property::Value arg3 ;
64091   Dali::Property::Value *argp3 ;
64092   SwigDirector_ViewImpl *darg = 0;
64093
64094   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64095   arg2 = (Dali::Property::Index)jarg2;
64096   argp3 = (Dali::Property::Value *)jarg3;
64097   if (!argp3) {
64098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64099     return ;
64100   }
64101   arg3 = *argp3;
64102   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64103   if (!darg) {
64104     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64105     return;
64106   }
64107   {
64108     try {
64109       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64110     } catch (std::out_of_range& e) {
64111       {
64112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64113       };
64114     } catch (std::exception& e) {
64115       {
64116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64117       };
64118     } catch (Dali::DaliException e) {
64119       {
64120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64121       };
64122     } catch (...) {
64123       {
64124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64125       };
64126     }
64127   }
64128
64129 }
64130
64131
64132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64133   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64134   Dali::Vector3 *arg2 = 0 ;
64135   SwigDirector_ViewImpl *darg = 0;
64136
64137   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64138   arg2 = (Dali::Vector3 *)jarg2;
64139   if (!arg2) {
64140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64141     return ;
64142   }
64143   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64144   if (!darg) {
64145     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64146     return;
64147   }
64148   {
64149     try {
64150       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64151     } catch (std::out_of_range& e) {
64152       {
64153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64154       };
64155     } catch (std::exception& e) {
64156       {
64157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64158       };
64159     } catch (Dali::DaliException e) {
64160       {
64161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64162       };
64163     } catch (...) {
64164       {
64165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64166       };
64167     }
64168   }
64169
64170 }
64171
64172
64173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64174   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64175   Dali::Vector3 *arg2 = 0 ;
64176   SwigDirector_ViewImpl *darg = 0;
64177
64178   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64179   arg2 = (Dali::Vector3 *)jarg2;
64180   if (!arg2) {
64181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64182     return ;
64183   }
64184   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64185   if (!darg) {
64186     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64187     return;
64188   }
64189   {
64190     try {
64191       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64192     } catch (std::out_of_range& e) {
64193       {
64194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64195       };
64196     } catch (std::exception& e) {
64197       {
64198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64199       };
64200     } catch (Dali::DaliException e) {
64201       {
64202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64203       };
64204     } catch (...) {
64205       {
64206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64207       };
64208     }
64209   }
64210
64211 }
64212
64213
64214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64215   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64216   Dali::Animation *arg2 = 0 ;
64217   Dali::Vector3 *arg3 = 0 ;
64218   SwigDirector_ViewImpl *darg = 0;
64219
64220   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64221   arg2 = (Dali::Animation *)jarg2;
64222   if (!arg2) {
64223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64224     return ;
64225   }
64226   arg3 = (Dali::Vector3 *)jarg3;
64227   if (!arg3) {
64228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64229     return ;
64230   }
64231   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64232   if (!darg) {
64233     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64234     return;
64235   }
64236   {
64237     try {
64238       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64239     } catch (std::out_of_range& e) {
64240       {
64241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64242       };
64243     } catch (std::exception& e) {
64244       {
64245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64246       };
64247     } catch (Dali::DaliException e) {
64248       {
64249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64250       };
64251     } catch (...) {
64252       {
64253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64254       };
64255     }
64256   }
64257
64258 }
64259
64260
64261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64262   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64263   Dali::Animation *arg2 = 0 ;
64264   Dali::Vector3 *arg3 = 0 ;
64265   SwigDirector_ViewImpl *darg = 0;
64266
64267   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64268   arg2 = (Dali::Animation *)jarg2;
64269   if (!arg2) {
64270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64271     return ;
64272   }
64273   arg3 = (Dali::Vector3 *)jarg3;
64274   if (!arg3) {
64275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64276     return ;
64277   }
64278   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64279   if (!darg) {
64280     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64281     return;
64282   }
64283   {
64284     try {
64285       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64286     } catch (std::out_of_range& e) {
64287       {
64288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64289       };
64290     } catch (std::exception& e) {
64291       {
64292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64293       };
64294     } catch (Dali::DaliException e) {
64295       {
64296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64297       };
64298     } catch (...) {
64299       {
64300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64301       };
64302     }
64303   }
64304
64305 }
64306
64307
64308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64309   unsigned int jresult ;
64310   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64311   Dali::TouchEvent *arg2 = 0 ;
64312   SwigDirector_ViewImpl *darg = 0;
64313   bool result;
64314
64315   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64316   arg2 = (Dali::TouchEvent *)jarg2;
64317   if (!arg2) {
64318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64319     return 0;
64320   }
64321   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64322   if (!darg) {
64323     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64324     return 0;
64325   }
64326   {
64327     try {
64328       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64329     } catch (std::out_of_range& e) {
64330       {
64331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64332       };
64333     } catch (std::exception& e) {
64334       {
64335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64336       };
64337     } catch (Dali::DaliException e) {
64338       {
64339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64340       };
64341     } catch (...) {
64342       {
64343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64344       };
64345     }
64346   }
64347
64348   jresult = result;
64349   return jresult;
64350 }
64351
64352
64353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64354   unsigned int jresult ;
64355   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64356   Dali::TouchEvent *arg2 = 0 ;
64357   SwigDirector_ViewImpl *darg = 0;
64358   bool result;
64359
64360   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64361   arg2 = (Dali::TouchEvent *)jarg2;
64362   if (!arg2) {
64363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64364     return 0;
64365   }
64366   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64367   if (!darg) {
64368     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64369     return 0;
64370   }
64371   {
64372     try {
64373       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64374     } catch (std::out_of_range& e) {
64375       {
64376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64377       };
64378     } catch (std::exception& e) {
64379       {
64380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64381       };
64382     } catch (Dali::DaliException e) {
64383       {
64384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64385       };
64386     } catch (...) {
64387       {
64388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64389       };
64390     }
64391   }
64392
64393   jresult = result;
64394   return jresult;
64395 }
64396
64397
64398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64399   unsigned int jresult ;
64400   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64401   Dali::HoverEvent *arg2 = 0 ;
64402   SwigDirector_ViewImpl *darg = 0;
64403   bool result;
64404
64405   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64406   arg2 = (Dali::HoverEvent *)jarg2;
64407   if (!arg2) {
64408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64409     return 0;
64410   }
64411   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64412   if (!darg) {
64413     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64414     return 0;
64415   }
64416   {
64417     try {
64418       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64419     } catch (std::out_of_range& e) {
64420       {
64421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64422       };
64423     } catch (std::exception& e) {
64424       {
64425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64426       };
64427     } catch (Dali::DaliException e) {
64428       {
64429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64430       };
64431     } catch (...) {
64432       {
64433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64434       };
64435     }
64436   }
64437
64438   jresult = result;
64439   return jresult;
64440 }
64441
64442
64443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64444   unsigned int jresult ;
64445   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64446   Dali::HoverEvent *arg2 = 0 ;
64447   SwigDirector_ViewImpl *darg = 0;
64448   bool result;
64449
64450   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64451   arg2 = (Dali::HoverEvent *)jarg2;
64452   if (!arg2) {
64453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64454     return 0;
64455   }
64456   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64457   if (!darg) {
64458     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64459     return 0;
64460   }
64461   {
64462     try {
64463       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64464     } catch (std::out_of_range& e) {
64465       {
64466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64467       };
64468     } catch (std::exception& e) {
64469       {
64470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64471       };
64472     } catch (Dali::DaliException e) {
64473       {
64474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64475       };
64476     } catch (...) {
64477       {
64478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64479       };
64480     }
64481   }
64482
64483   jresult = result;
64484   return jresult;
64485 }
64486
64487
64488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64489   unsigned int jresult ;
64490   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64491   Dali::KeyEvent *arg2 = 0 ;
64492   SwigDirector_ViewImpl *darg = 0;
64493   bool result;
64494
64495   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64496   arg2 = (Dali::KeyEvent *)jarg2;
64497   if (!arg2) {
64498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64499     return 0;
64500   }
64501   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64502   if (!darg) {
64503     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64504     return 0;
64505   }
64506   {
64507     try {
64508       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64509     } catch (std::out_of_range& e) {
64510       {
64511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64512       };
64513     } catch (std::exception& e) {
64514       {
64515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64516       };
64517     } catch (Dali::DaliException e) {
64518       {
64519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64520       };
64521     } catch (...) {
64522       {
64523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64524       };
64525     }
64526   }
64527
64528   jresult = result;
64529   return jresult;
64530 }
64531
64532
64533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64534   unsigned int jresult ;
64535   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64536   Dali::KeyEvent *arg2 = 0 ;
64537   SwigDirector_ViewImpl *darg = 0;
64538   bool result;
64539
64540   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64541   arg2 = (Dali::KeyEvent *)jarg2;
64542   if (!arg2) {
64543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64544     return 0;
64545   }
64546   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64547   if (!darg) {
64548     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64549     return 0;
64550   }
64551   {
64552     try {
64553       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64554     } catch (std::out_of_range& e) {
64555       {
64556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64557       };
64558     } catch (std::exception& e) {
64559       {
64560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64561       };
64562     } catch (Dali::DaliException e) {
64563       {
64564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64565       };
64566     } catch (...) {
64567       {
64568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64569       };
64570     }
64571   }
64572
64573   jresult = result;
64574   return jresult;
64575 }
64576
64577
64578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64579   unsigned int jresult ;
64580   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64581   Dali::WheelEvent *arg2 = 0 ;
64582   SwigDirector_ViewImpl *darg = 0;
64583   bool result;
64584
64585   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64586   arg2 = (Dali::WheelEvent *)jarg2;
64587   if (!arg2) {
64588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64589     return 0;
64590   }
64591   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64592   if (!darg) {
64593     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64594     return 0;
64595   }
64596   {
64597     try {
64598       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64599     } catch (std::out_of_range& e) {
64600       {
64601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64602       };
64603     } catch (std::exception& e) {
64604       {
64605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64606       };
64607     } catch (Dali::DaliException e) {
64608       {
64609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64610       };
64611     } catch (...) {
64612       {
64613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64614       };
64615     }
64616   }
64617
64618   jresult = result;
64619   return jresult;
64620 }
64621
64622
64623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64624   unsigned int jresult ;
64625   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64626   Dali::WheelEvent *arg2 = 0 ;
64627   SwigDirector_ViewImpl *darg = 0;
64628   bool result;
64629
64630   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64631   arg2 = (Dali::WheelEvent *)jarg2;
64632   if (!arg2) {
64633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64634     return 0;
64635   }
64636   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64637   if (!darg) {
64638     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64639     return 0;
64640   }
64641   {
64642     try {
64643       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64644     } catch (std::out_of_range& e) {
64645       {
64646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64647       };
64648     } catch (std::exception& e) {
64649       {
64650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64651       };
64652     } catch (Dali::DaliException e) {
64653       {
64654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64655       };
64656     } catch (...) {
64657       {
64658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64659       };
64660     }
64661   }
64662
64663   jresult = result;
64664   return jresult;
64665 }
64666
64667
64668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64669   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64670   Dali::Vector2 *arg2 = 0 ;
64671   Dali::RelayoutContainer *arg3 = 0 ;
64672   SwigDirector_ViewImpl *darg = 0;
64673
64674   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64675   arg2 = (Dali::Vector2 *)jarg2;
64676   if (!arg2) {
64677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64678     return ;
64679   }
64680   arg3 = (Dali::RelayoutContainer *)jarg3;
64681   if (!arg3) {
64682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64683     return ;
64684   }
64685   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64686   if (!darg) {
64687     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64688     return;
64689   }
64690   {
64691     try {
64692       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64693     } catch (std::out_of_range& e) {
64694       {
64695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64696       };
64697     } catch (std::exception& e) {
64698       {
64699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64700       };
64701     } catch (Dali::DaliException e) {
64702       {
64703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64704       };
64705     } catch (...) {
64706       {
64707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64708       };
64709     }
64710   }
64711
64712 }
64713
64714
64715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64716   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64717   Dali::Vector2 *arg2 = 0 ;
64718   Dali::RelayoutContainer *arg3 = 0 ;
64719   SwigDirector_ViewImpl *darg = 0;
64720
64721   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64722   arg2 = (Dali::Vector2 *)jarg2;
64723   if (!arg2) {
64724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64725     return ;
64726   }
64727   arg3 = (Dali::RelayoutContainer *)jarg3;
64728   if (!arg3) {
64729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64730     return ;
64731   }
64732   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64733   if (!darg) {
64734     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64735     return;
64736   }
64737   {
64738     try {
64739       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64740     } catch (std::out_of_range& e) {
64741       {
64742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64743       };
64744     } catch (std::exception& e) {
64745       {
64746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64747       };
64748     } catch (Dali::DaliException e) {
64749       {
64750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64751       };
64752     } catch (...) {
64753       {
64754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64755       };
64756     }
64757   }
64758
64759 }
64760
64761
64762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64763   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64764   Dali::ResizePolicy::Type arg2 ;
64765   Dali::Dimension::Type arg3 ;
64766   SwigDirector_ViewImpl *darg = 0;
64767
64768   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64769   arg2 = (Dali::ResizePolicy::Type)jarg2;
64770   arg3 = (Dali::Dimension::Type)jarg3;
64771   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64772   if (!darg) {
64773     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64774     return;
64775   }
64776   {
64777     try {
64778       (darg)->OnSetResizePolicy(arg2,arg3);
64779     } catch (std::out_of_range& e) {
64780       {
64781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64782       };
64783     } catch (std::exception& e) {
64784       {
64785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64786       };
64787     } catch (Dali::DaliException e) {
64788       {
64789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64790       };
64791     } catch (...) {
64792       {
64793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64794       };
64795     }
64796   }
64797
64798 }
64799
64800
64801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
64802   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64803   Dali::ResizePolicy::Type arg2 ;
64804   Dali::Dimension::Type arg3 ;
64805   SwigDirector_ViewImpl *darg = 0;
64806
64807   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64808   arg2 = (Dali::ResizePolicy::Type)jarg2;
64809   arg3 = (Dali::Dimension::Type)jarg3;
64810   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64811   if (!darg) {
64812     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64813     return;
64814   }
64815   {
64816     try {
64817       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
64818     } catch (std::out_of_range& e) {
64819       {
64820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64821       };
64822     } catch (std::exception& e) {
64823       {
64824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64825       };
64826     } catch (Dali::DaliException e) {
64827       {
64828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64829       };
64830     } catch (...) {
64831       {
64832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64833       };
64834     }
64835   }
64836
64837 }
64838
64839
64840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
64841   void * jresult ;
64842   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64843   SwigDirector_ViewImpl *darg = 0;
64844   Dali::Vector3 result;
64845
64846   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64847   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64848   if (!darg) {
64849     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64850     return 0;
64851   }
64852   {
64853     try {
64854       result = (darg)->GetNaturalSize();
64855     } catch (std::out_of_range& e) {
64856       {
64857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64858       };
64859     } catch (std::exception& e) {
64860       {
64861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64862       };
64863     } catch (Dali::DaliException e) {
64864       {
64865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64866       };
64867     } catch (...) {
64868       {
64869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64870       };
64871     }
64872   }
64873
64874   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64875   return jresult;
64876 }
64877
64878
64879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
64880   void * jresult ;
64881   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64882   SwigDirector_ViewImpl *darg = 0;
64883   Dali::Vector3 result;
64884
64885   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64886   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64887   if (!darg) {
64888     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64889     return 0;
64890   }
64891   {
64892     try {
64893       result = (darg)->GetNaturalSizeSwigPublic();
64894     } catch (std::out_of_range& e) {
64895       {
64896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64897       };
64898     } catch (std::exception& e) {
64899       {
64900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64901       };
64902     } catch (Dali::DaliException e) {
64903       {
64904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64905       };
64906     } catch (...) {
64907       {
64908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64909       };
64910     }
64911   }
64912
64913   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64914   return jresult;
64915 }
64916
64917
64918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
64919   float jresult ;
64920   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64921   Dali::Actor *arg2 = 0 ;
64922   Dali::Dimension::Type arg3 ;
64923   SwigDirector_ViewImpl *darg = 0;
64924   float result;
64925
64926   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64927   arg2 = (Dali::Actor *)jarg2;
64928   if (!arg2) {
64929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64930     return 0;
64931   }
64932   arg3 = (Dali::Dimension::Type)jarg3;
64933   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64934   if (!darg) {
64935     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64936     return 0;
64937   }
64938   {
64939     try {
64940       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
64941     } catch (std::out_of_range& e) {
64942       {
64943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64944       };
64945     } catch (std::exception& e) {
64946       {
64947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64948       };
64949     } catch (Dali::DaliException e) {
64950       {
64951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64952       };
64953     } catch (...) {
64954       {
64955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64956       };
64957     }
64958   }
64959
64960   jresult = result;
64961   return jresult;
64962 }
64963
64964
64965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
64966   float jresult ;
64967   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64968   Dali::Actor *arg2 = 0 ;
64969   Dali::Dimension::Type arg3 ;
64970   SwigDirector_ViewImpl *darg = 0;
64971   float result;
64972
64973   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64974   arg2 = (Dali::Actor *)jarg2;
64975   if (!arg2) {
64976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64977     return 0;
64978   }
64979   arg3 = (Dali::Dimension::Type)jarg3;
64980   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64981   if (!darg) {
64982     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64983     return 0;
64984   }
64985   {
64986     try {
64987       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
64988     } catch (std::out_of_range& e) {
64989       {
64990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64991       };
64992     } catch (std::exception& e) {
64993       {
64994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64995       };
64996     } catch (Dali::DaliException e) {
64997       {
64998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64999       };
65000     } catch (...) {
65001       {
65002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65003       };
65004     }
65005   }
65006
65007   jresult = result;
65008   return jresult;
65009 }
65010
65011
65012 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65013   float jresult ;
65014   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65015   float arg2 ;
65016   SwigDirector_ViewImpl *darg = 0;
65017   float result;
65018
65019   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65020   arg2 = (float)jarg2;
65021   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65022   if (!darg) {
65023     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65024     return 0;
65025   }
65026   {
65027     try {
65028       result = (float)(darg)->GetHeightForWidth(arg2);
65029     } catch (std::out_of_range& e) {
65030       {
65031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65032       };
65033     } catch (std::exception& e) {
65034       {
65035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65036       };
65037     } catch (Dali::DaliException e) {
65038       {
65039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65040       };
65041     } catch (...) {
65042       {
65043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65044       };
65045     }
65046   }
65047
65048   jresult = result;
65049   return jresult;
65050 }
65051
65052
65053 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65054   float jresult ;
65055   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65056   float arg2 ;
65057   SwigDirector_ViewImpl *darg = 0;
65058   float result;
65059
65060   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65061   arg2 = (float)jarg2;
65062   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65063   if (!darg) {
65064     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65065     return 0;
65066   }
65067   {
65068     try {
65069       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65070     } catch (std::out_of_range& e) {
65071       {
65072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65073       };
65074     } catch (std::exception& e) {
65075       {
65076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65077       };
65078     } catch (Dali::DaliException e) {
65079       {
65080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65081       };
65082     } catch (...) {
65083       {
65084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65085       };
65086     }
65087   }
65088
65089   jresult = result;
65090   return jresult;
65091 }
65092
65093
65094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65095   float jresult ;
65096   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65097   float arg2 ;
65098   SwigDirector_ViewImpl *darg = 0;
65099   float result;
65100
65101   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65102   arg2 = (float)jarg2;
65103   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65104   if (!darg) {
65105     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65106     return 0;
65107   }
65108   {
65109     try {
65110       result = (float)(darg)->GetWidthForHeight(arg2);
65111     } catch (std::out_of_range& e) {
65112       {
65113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65114       };
65115     } catch (std::exception& e) {
65116       {
65117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65118       };
65119     } catch (Dali::DaliException e) {
65120       {
65121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65122       };
65123     } catch (...) {
65124       {
65125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65126       };
65127     }
65128   }
65129
65130   jresult = result;
65131   return jresult;
65132 }
65133
65134
65135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65136   float jresult ;
65137   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65138   float arg2 ;
65139   SwigDirector_ViewImpl *darg = 0;
65140   float result;
65141
65142   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65143   arg2 = (float)jarg2;
65144   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65145   if (!darg) {
65146     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65147     return 0;
65148   }
65149   {
65150     try {
65151       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65152     } catch (std::out_of_range& e) {
65153       {
65154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65155       };
65156     } catch (std::exception& e) {
65157       {
65158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65159       };
65160     } catch (Dali::DaliException e) {
65161       {
65162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65163       };
65164     } catch (...) {
65165       {
65166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65167       };
65168     }
65169   }
65170
65171   jresult = result;
65172   return jresult;
65173 }
65174
65175
65176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65177   unsigned int jresult ;
65178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65179   Dali::Dimension::Type arg2 ;
65180   SwigDirector_ViewImpl *darg = 0;
65181   bool result;
65182
65183   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65184   arg2 = (Dali::Dimension::Type)jarg2;
65185   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65186   if (!darg) {
65187     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65188     return 0;
65189   }
65190   {
65191     try {
65192       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65193     } catch (std::out_of_range& e) {
65194       {
65195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65196       };
65197     } catch (std::exception& e) {
65198       {
65199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65200       };
65201     } catch (Dali::DaliException e) {
65202       {
65203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65204       };
65205     } catch (...) {
65206       {
65207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65208       };
65209     }
65210   }
65211
65212   jresult = result;
65213   return jresult;
65214 }
65215
65216
65217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65218   unsigned int jresult ;
65219   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65220   Dali::Dimension::Type arg2 ;
65221   SwigDirector_ViewImpl *darg = 0;
65222   bool result;
65223
65224   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65225   arg2 = (Dali::Dimension::Type)jarg2;
65226   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65227   if (!darg) {
65228     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65229     return 0;
65230   }
65231   {
65232     try {
65233       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65234     } catch (std::out_of_range& e) {
65235       {
65236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65237       };
65238     } catch (std::exception& e) {
65239       {
65240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65241       };
65242     } catch (Dali::DaliException e) {
65243       {
65244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65245       };
65246     } catch (...) {
65247       {
65248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65249       };
65250     }
65251   }
65252
65253   jresult = result;
65254   return jresult;
65255 }
65256
65257
65258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65259   unsigned int jresult ;
65260   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65261   SwigDirector_ViewImpl *darg = 0;
65262   bool result;
65263
65264   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65265   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65266   if (!darg) {
65267     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65268     return 0;
65269   }
65270   {
65271     try {
65272       result = (bool)(darg)->RelayoutDependentOnChildren();
65273     } catch (std::out_of_range& e) {
65274       {
65275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65276       };
65277     } catch (std::exception& e) {
65278       {
65279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65280       };
65281     } catch (Dali::DaliException e) {
65282       {
65283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65284       };
65285     } catch (...) {
65286       {
65287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65288       };
65289     }
65290   }
65291
65292   jresult = result;
65293   return jresult;
65294 }
65295
65296
65297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65298   unsigned int jresult ;
65299   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65300   SwigDirector_ViewImpl *darg = 0;
65301   bool result;
65302
65303   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65304   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65305   if (!darg) {
65306     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65307     return 0;
65308   }
65309   {
65310     try {
65311       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65312     } catch (std::out_of_range& e) {
65313       {
65314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65315       };
65316     } catch (std::exception& e) {
65317       {
65318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65319       };
65320     } catch (Dali::DaliException e) {
65321       {
65322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65323       };
65324     } catch (...) {
65325       {
65326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65327       };
65328     }
65329   }
65330
65331   jresult = result;
65332   return jresult;
65333 }
65334
65335
65336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65337   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65338   Dali::Dimension::Type arg2 ;
65339   SwigDirector_ViewImpl *darg = 0;
65340
65341   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65342   arg2 = (Dali::Dimension::Type)jarg2;
65343   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65344   if (!darg) {
65345     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65346     return;
65347   }
65348   {
65349     try {
65350       (darg)->OnCalculateRelayoutSize(arg2);
65351     } catch (std::out_of_range& e) {
65352       {
65353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65354       };
65355     } catch (std::exception& e) {
65356       {
65357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65358       };
65359     } catch (Dali::DaliException e) {
65360       {
65361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65362       };
65363     } catch (...) {
65364       {
65365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65366       };
65367     }
65368   }
65369
65370 }
65371
65372
65373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65375   Dali::Dimension::Type arg2 ;
65376   SwigDirector_ViewImpl *darg = 0;
65377
65378   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65379   arg2 = (Dali::Dimension::Type)jarg2;
65380   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65381   if (!darg) {
65382     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65383     return;
65384   }
65385   {
65386     try {
65387       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65388     } catch (std::out_of_range& e) {
65389       {
65390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65391       };
65392     } catch (std::exception& e) {
65393       {
65394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65395       };
65396     } catch (Dali::DaliException e) {
65397       {
65398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65399       };
65400     } catch (...) {
65401       {
65402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65403       };
65404     }
65405   }
65406
65407 }
65408
65409
65410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65411   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65412   float arg2 ;
65413   Dali::Dimension::Type arg3 ;
65414   SwigDirector_ViewImpl *darg = 0;
65415
65416   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65417   arg2 = (float)jarg2;
65418   arg3 = (Dali::Dimension::Type)jarg3;
65419   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65420   if (!darg) {
65421     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65422     return;
65423   }
65424   {
65425     try {
65426       (darg)->OnLayoutNegotiated(arg2,arg3);
65427     } catch (std::out_of_range& e) {
65428       {
65429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65430       };
65431     } catch (std::exception& e) {
65432       {
65433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65434       };
65435     } catch (Dali::DaliException e) {
65436       {
65437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65438       };
65439     } catch (...) {
65440       {
65441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65442       };
65443     }
65444   }
65445
65446 }
65447
65448
65449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65450   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65451   float arg2 ;
65452   Dali::Dimension::Type arg3 ;
65453   SwigDirector_ViewImpl *darg = 0;
65454
65455   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65456   arg2 = (float)jarg2;
65457   arg3 = (Dali::Dimension::Type)jarg3;
65458   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65459   if (!darg) {
65460     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65461     return;
65462   }
65463   {
65464     try {
65465       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65466     } catch (std::out_of_range& e) {
65467       {
65468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65469       };
65470     } catch (std::exception& e) {
65471       {
65472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65473       };
65474     } catch (Dali::DaliException e) {
65475       {
65476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65477       };
65478     } catch (...) {
65479       {
65480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65481       };
65482     }
65483   }
65484
65485 }
65486
65487
65488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65489   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65490
65491   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65492   {
65493     try {
65494       (arg1)->OnInitialize();
65495     } catch (std::out_of_range& e) {
65496       {
65497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65498       };
65499     } catch (std::exception& e) {
65500       {
65501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65502       };
65503     } catch (Dali::DaliException e) {
65504       {
65505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65506       };
65507     } catch (...) {
65508       {
65509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65510       };
65511     }
65512   }
65513
65514 }
65515
65516
65517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65518   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65519
65520   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65521   {
65522     try {
65523       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65524     } catch (std::out_of_range& e) {
65525       {
65526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65527       };
65528     } catch (std::exception& e) {
65529       {
65530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65531       };
65532     } catch (Dali::DaliException e) {
65533       {
65534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65535       };
65536     } catch (...) {
65537       {
65538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65539       };
65540     }
65541   }
65542
65543 }
65544
65545
65546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65547   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65548   Dali::Actor *arg2 = 0 ;
65549
65550   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65551   arg2 = (Dali::Actor *)jarg2;
65552   if (!arg2) {
65553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65554     return ;
65555   }
65556   {
65557     try {
65558       (arg1)->OnControlChildAdd(*arg2);
65559     } catch (std::out_of_range& e) {
65560       {
65561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65562       };
65563     } catch (std::exception& e) {
65564       {
65565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65566       };
65567     } catch (Dali::DaliException e) {
65568       {
65569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65570       };
65571     } catch (...) {
65572       {
65573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65574       };
65575     }
65576   }
65577
65578 }
65579
65580
65581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65582   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65583   Dali::Actor *arg2 = 0 ;
65584
65585   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65586   arg2 = (Dali::Actor *)jarg2;
65587   if (!arg2) {
65588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65589     return ;
65590   }
65591   {
65592     try {
65593       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65594     } catch (std::out_of_range& e) {
65595       {
65596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65597       };
65598     } catch (std::exception& e) {
65599       {
65600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65601       };
65602     } catch (Dali::DaliException e) {
65603       {
65604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65605       };
65606     } catch (...) {
65607       {
65608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65609       };
65610     }
65611   }
65612
65613 }
65614
65615
65616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65617   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65618   Dali::Actor *arg2 = 0 ;
65619
65620   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65621   arg2 = (Dali::Actor *)jarg2;
65622   if (!arg2) {
65623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65624     return ;
65625   }
65626   {
65627     try {
65628       (arg1)->OnControlChildRemove(*arg2);
65629     } catch (std::out_of_range& e) {
65630       {
65631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65632       };
65633     } catch (std::exception& e) {
65634       {
65635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65636       };
65637     } catch (Dali::DaliException e) {
65638       {
65639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65640       };
65641     } catch (...) {
65642       {
65643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65644       };
65645     }
65646   }
65647
65648 }
65649
65650
65651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65652   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65653   Dali::Actor *arg2 = 0 ;
65654
65655   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65656   arg2 = (Dali::Actor *)jarg2;
65657   if (!arg2) {
65658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65659     return ;
65660   }
65661   {
65662     try {
65663       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65664     } catch (std::out_of_range& e) {
65665       {
65666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65667       };
65668     } catch (std::exception& e) {
65669       {
65670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65671       };
65672     } catch (Dali::DaliException e) {
65673       {
65674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65675       };
65676     } catch (...) {
65677       {
65678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65679       };
65680     }
65681   }
65682
65683 }
65684
65685
65686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65687   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65688   Dali::Toolkit::StyleManager arg2 ;
65689   Dali::StyleChange::Type arg3 ;
65690   Dali::Toolkit::StyleManager *argp2 ;
65691
65692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65693   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65694   if (!argp2) {
65695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65696     return ;
65697   }
65698   arg2 = *argp2;
65699   arg3 = (Dali::StyleChange::Type)jarg3;
65700   {
65701     try {
65702       (arg1)->OnStyleChange(arg2,arg3);
65703     } catch (std::out_of_range& e) {
65704       {
65705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65706       };
65707     } catch (std::exception& e) {
65708       {
65709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65710       };
65711     } catch (Dali::DaliException e) {
65712       {
65713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65714       };
65715     } catch (...) {
65716       {
65717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65718       };
65719     }
65720   }
65721
65722 }
65723
65724
65725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65726   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65727   Dali::Toolkit::StyleManager arg2 ;
65728   Dali::StyleChange::Type arg3 ;
65729   Dali::Toolkit::StyleManager *argp2 ;
65730
65731   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65732   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65733   if (!argp2) {
65734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65735     return ;
65736   }
65737   arg2 = *argp2;
65738   arg3 = (Dali::StyleChange::Type)jarg3;
65739   {
65740     try {
65741       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65742     } catch (std::out_of_range& e) {
65743       {
65744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65745       };
65746     } catch (std::exception& e) {
65747       {
65748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65749       };
65750     } catch (Dali::DaliException e) {
65751       {
65752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65753       };
65754     } catch (...) {
65755       {
65756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65757       };
65758     }
65759   }
65760
65761 }
65762
65763
65764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65765   unsigned int jresult ;
65766   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65767   bool result;
65768
65769   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65770   {
65771     try {
65772       result = (bool)(arg1)->OnAccessibilityActivated();
65773     } catch (std::out_of_range& e) {
65774       {
65775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65776       };
65777     } catch (std::exception& e) {
65778       {
65779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65780       };
65781     } catch (Dali::DaliException e) {
65782       {
65783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65784       };
65785     } catch (...) {
65786       {
65787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65788       };
65789     }
65790   }
65791
65792   jresult = result;
65793   return jresult;
65794 }
65795
65796
65797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
65798   unsigned int jresult ;
65799   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65800   bool result;
65801
65802   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65803   {
65804     try {
65805       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
65806     } catch (std::out_of_range& e) {
65807       {
65808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65809       };
65810     } catch (std::exception& e) {
65811       {
65812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65813       };
65814     } catch (Dali::DaliException e) {
65815       {
65816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65817       };
65818     } catch (...) {
65819       {
65820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65821       };
65822     }
65823   }
65824
65825   jresult = result;
65826   return jresult;
65827 }
65828
65829
65830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
65831   unsigned int jresult ;
65832   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65833   Dali::PanGesture arg2 ;
65834   Dali::PanGesture *argp2 ;
65835   bool result;
65836
65837   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65838   argp2 = (Dali::PanGesture *)jarg2;
65839   if (!argp2) {
65840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65841     return 0;
65842   }
65843   arg2 = *argp2;
65844   {
65845     try {
65846       result = (bool)(arg1)->OnAccessibilityPan(arg2);
65847     } catch (std::out_of_range& e) {
65848       {
65849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65850       };
65851     } catch (std::exception& e) {
65852       {
65853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65854       };
65855     } catch (Dali::DaliException e) {
65856       {
65857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65858       };
65859     } catch (...) {
65860       {
65861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65862       };
65863     }
65864   }
65865
65866   jresult = result;
65867   return jresult;
65868 }
65869
65870
65871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65872   unsigned int jresult ;
65873   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65874   Dali::PanGesture arg2 ;
65875   Dali::PanGesture *argp2 ;
65876   bool result;
65877
65878   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65879   argp2 = (Dali::PanGesture *)jarg2;
65880   if (!argp2) {
65881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65882     return 0;
65883   }
65884   arg2 = *argp2;
65885   {
65886     try {
65887       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
65888     } catch (std::out_of_range& e) {
65889       {
65890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65891       };
65892     } catch (std::exception& e) {
65893       {
65894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65895       };
65896     } catch (Dali::DaliException e) {
65897       {
65898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65899       };
65900     } catch (...) {
65901       {
65902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65903       };
65904     }
65905   }
65906
65907   jresult = result;
65908   return jresult;
65909 }
65910
65911
65912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
65913   unsigned int jresult ;
65914   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65915   Dali::TouchEvent *arg2 = 0 ;
65916   bool result;
65917
65918   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65919   arg2 = (Dali::TouchEvent *)jarg2;
65920   if (!arg2) {
65921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65922     return 0;
65923   }
65924   {
65925     try {
65926       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65927     } catch (std::out_of_range& e) {
65928       {
65929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65930       };
65931     } catch (std::exception& e) {
65932       {
65933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65934       };
65935     } catch (Dali::DaliException e) {
65936       {
65937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65938       };
65939     } catch (...) {
65940       {
65941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65942       };
65943     }
65944   }
65945
65946   jresult = result;
65947   return jresult;
65948 }
65949
65950
65951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65952   unsigned int jresult ;
65953   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65954   Dali::TouchEvent *arg2 = 0 ;
65955   bool result;
65956
65957   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65958   arg2 = (Dali::TouchEvent *)jarg2;
65959   if (!arg2) {
65960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65961     return 0;
65962   }
65963   {
65964     try {
65965       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65966     } catch (std::out_of_range& e) {
65967       {
65968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65969       };
65970     } catch (std::exception& e) {
65971       {
65972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65973       };
65974     } catch (Dali::DaliException e) {
65975       {
65976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65977       };
65978     } catch (...) {
65979       {
65980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65981       };
65982     }
65983   }
65984
65985   jresult = result;
65986   return jresult;
65987 }
65988
65989
65990 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
65991   unsigned int jresult ;
65992   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65993   bool arg2 ;
65994   bool result;
65995
65996   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65997   arg2 = jarg2 ? true : false;
65998   {
65999     try {
66000       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66001     } catch (std::out_of_range& e) {
66002       {
66003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66004       };
66005     } catch (std::exception& e) {
66006       {
66007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66008       };
66009     } catch (Dali::DaliException e) {
66010       {
66011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66012       };
66013     } catch (...) {
66014       {
66015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66016       };
66017     }
66018   }
66019
66020   jresult = result;
66021   return jresult;
66022 }
66023
66024
66025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66026   unsigned int jresult ;
66027   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66028   bool arg2 ;
66029   bool result;
66030
66031   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66032   arg2 = jarg2 ? true : false;
66033   {
66034     try {
66035       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66036     } catch (std::out_of_range& e) {
66037       {
66038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66039       };
66040     } catch (std::exception& e) {
66041       {
66042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66043       };
66044     } catch (Dali::DaliException e) {
66045       {
66046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66047       };
66048     } catch (...) {
66049       {
66050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66051       };
66052     }
66053   }
66054
66055   jresult = result;
66056   return jresult;
66057 }
66058
66059
66060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66061   unsigned int jresult ;
66062   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66063   bool result;
66064
66065   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66066   {
66067     try {
66068       result = (bool)(arg1)->OnAccessibilityZoom();
66069     } catch (std::out_of_range& e) {
66070       {
66071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66072       };
66073     } catch (std::exception& e) {
66074       {
66075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66076       };
66077     } catch (Dali::DaliException e) {
66078       {
66079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66080       };
66081     } catch (...) {
66082       {
66083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66084       };
66085     }
66086   }
66087
66088   jresult = result;
66089   return jresult;
66090 }
66091
66092
66093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66094   unsigned int jresult ;
66095   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66096   bool result;
66097
66098   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66099   {
66100     try {
66101       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66102     } catch (std::out_of_range& e) {
66103       {
66104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66105       };
66106     } catch (std::exception& e) {
66107       {
66108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66109       };
66110     } catch (Dali::DaliException e) {
66111       {
66112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66113       };
66114     } catch (...) {
66115       {
66116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66117       };
66118     }
66119   }
66120
66121   jresult = result;
66122   return jresult;
66123 }
66124
66125
66126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66127   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66128
66129   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66130   {
66131     try {
66132       (arg1)->OnKeyInputFocusGained();
66133     } catch (std::out_of_range& e) {
66134       {
66135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66136       };
66137     } catch (std::exception& e) {
66138       {
66139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66140       };
66141     } catch (Dali::DaliException e) {
66142       {
66143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66144       };
66145     } catch (...) {
66146       {
66147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66148       };
66149     }
66150   }
66151
66152 }
66153
66154
66155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66156   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66157
66158   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66159   {
66160     try {
66161       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66162     } catch (std::out_of_range& e) {
66163       {
66164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66165       };
66166     } catch (std::exception& e) {
66167       {
66168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66169       };
66170     } catch (Dali::DaliException e) {
66171       {
66172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66173       };
66174     } catch (...) {
66175       {
66176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66177       };
66178     }
66179   }
66180
66181 }
66182
66183
66184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66185   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66186
66187   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66188   {
66189     try {
66190       (arg1)->OnKeyInputFocusLost();
66191     } catch (std::out_of_range& e) {
66192       {
66193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66194       };
66195     } catch (std::exception& e) {
66196       {
66197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66198       };
66199     } catch (Dali::DaliException e) {
66200       {
66201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66202       };
66203     } catch (...) {
66204       {
66205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66206       };
66207     }
66208   }
66209
66210 }
66211
66212
66213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66214   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66215
66216   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66217   {
66218     try {
66219       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66220     } catch (std::out_of_range& e) {
66221       {
66222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66223       };
66224     } catch (std::exception& e) {
66225       {
66226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66227       };
66228     } catch (Dali::DaliException e) {
66229       {
66230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66231       };
66232     } catch (...) {
66233       {
66234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66235       };
66236     }
66237   }
66238
66239 }
66240
66241
66242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66243   void * jresult ;
66244   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66245   Dali::Actor arg2 ;
66246   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66247   bool arg4 ;
66248   Dali::Actor *argp2 ;
66249   Dali::Actor result;
66250
66251   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66252   argp2 = (Dali::Actor *)jarg2;
66253   if (!argp2) {
66254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66255     return 0;
66256   }
66257   arg2 = *argp2;
66258   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66259   arg4 = jarg4 ? true : false;
66260   {
66261     try {
66262       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66263     } catch (std::out_of_range& e) {
66264       {
66265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66266       };
66267     } catch (std::exception& e) {
66268       {
66269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66270       };
66271     } catch (Dali::DaliException e) {
66272       {
66273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66274       };
66275     } catch (...) {
66276       {
66277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66278       };
66279     }
66280   }
66281
66282   jresult = new Dali::Actor((const Dali::Actor &)result);
66283   return jresult;
66284 }
66285
66286
66287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66288   void * jresult ;
66289   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66290   Dali::Actor arg2 ;
66291   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66292   bool arg4 ;
66293   Dali::Actor *argp2 ;
66294   Dali::Actor result;
66295
66296   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66297   argp2 = (Dali::Actor *)jarg2;
66298   if (!argp2) {
66299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66300     return 0;
66301   }
66302   arg2 = *argp2;
66303   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66304   arg4 = jarg4 ? true : false;
66305   {
66306     try {
66307       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66308     } catch (std::out_of_range& e) {
66309       {
66310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66311       };
66312     } catch (std::exception& e) {
66313       {
66314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66315       };
66316     } catch (Dali::DaliException e) {
66317       {
66318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66319       };
66320     } catch (...) {
66321       {
66322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66323       };
66324     }
66325   }
66326
66327   jresult = new Dali::Actor((const Dali::Actor &)result);
66328   return jresult;
66329 }
66330
66331
66332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66333   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66334   Dali::Actor arg2 ;
66335   Dali::Actor *argp2 ;
66336
66337   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66338   argp2 = (Dali::Actor *)jarg2;
66339   if (!argp2) {
66340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66341     return ;
66342   }
66343   arg2 = *argp2;
66344   {
66345     try {
66346       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66347     } catch (std::out_of_range& e) {
66348       {
66349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66350       };
66351     } catch (std::exception& e) {
66352       {
66353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66354       };
66355     } catch (Dali::DaliException e) {
66356       {
66357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66358       };
66359     } catch (...) {
66360       {
66361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66362       };
66363     }
66364   }
66365
66366 }
66367
66368
66369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66370   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66371   Dali::Actor arg2 ;
66372   Dali::Actor *argp2 ;
66373
66374   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66375   argp2 = (Dali::Actor *)jarg2;
66376   if (!argp2) {
66377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66378     return ;
66379   }
66380   arg2 = *argp2;
66381   {
66382     try {
66383       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66384     } catch (std::out_of_range& e) {
66385       {
66386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66387       };
66388     } catch (std::exception& e) {
66389       {
66390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66391       };
66392     } catch (Dali::DaliException e) {
66393       {
66394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66395       };
66396     } catch (...) {
66397       {
66398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66399       };
66400     }
66401   }
66402
66403 }
66404
66405
66406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66407   unsigned int jresult ;
66408   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66409   bool result;
66410
66411   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66412   {
66413     try {
66414       result = (bool)(arg1)->OnKeyboardEnter();
66415     } catch (std::out_of_range& e) {
66416       {
66417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66418       };
66419     } catch (std::exception& e) {
66420       {
66421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66422       };
66423     } catch (Dali::DaliException e) {
66424       {
66425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66426       };
66427     } catch (...) {
66428       {
66429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66430       };
66431     }
66432   }
66433
66434   jresult = result;
66435   return jresult;
66436 }
66437
66438
66439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66440   unsigned int jresult ;
66441   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66442   bool result;
66443
66444   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66445   {
66446     try {
66447       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66448     } catch (std::out_of_range& e) {
66449       {
66450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66451       };
66452     } catch (std::exception& e) {
66453       {
66454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66455       };
66456     } catch (Dali::DaliException e) {
66457       {
66458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66459       };
66460     } catch (...) {
66461       {
66462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66463       };
66464     }
66465   }
66466
66467   jresult = result;
66468   return jresult;
66469 }
66470
66471
66472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66474   Dali::PinchGesture *arg2 = 0 ;
66475
66476   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66477   arg2 = (Dali::PinchGesture *)jarg2;
66478   if (!arg2) {
66479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66480     return ;
66481   }
66482   {
66483     try {
66484       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66485     } catch (std::out_of_range& e) {
66486       {
66487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66488       };
66489     } catch (std::exception& e) {
66490       {
66491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66492       };
66493     } catch (Dali::DaliException e) {
66494       {
66495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66496       };
66497     } catch (...) {
66498       {
66499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66500       };
66501     }
66502   }
66503
66504 }
66505
66506
66507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66508   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66509   Dali::PinchGesture *arg2 = 0 ;
66510
66511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66512   arg2 = (Dali::PinchGesture *)jarg2;
66513   if (!arg2) {
66514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66515     return ;
66516   }
66517   {
66518     try {
66519       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66520     } catch (std::out_of_range& e) {
66521       {
66522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66523       };
66524     } catch (std::exception& e) {
66525       {
66526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66527       };
66528     } catch (Dali::DaliException e) {
66529       {
66530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66531       };
66532     } catch (...) {
66533       {
66534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66535       };
66536     }
66537   }
66538
66539 }
66540
66541
66542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66543   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66544   Dali::PanGesture *arg2 = 0 ;
66545
66546   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66547   arg2 = (Dali::PanGesture *)jarg2;
66548   if (!arg2) {
66549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66550     return ;
66551   }
66552   {
66553     try {
66554       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66555     } catch (std::out_of_range& e) {
66556       {
66557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66558       };
66559     } catch (std::exception& e) {
66560       {
66561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66562       };
66563     } catch (Dali::DaliException e) {
66564       {
66565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66566       };
66567     } catch (...) {
66568       {
66569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66570       };
66571     }
66572   }
66573
66574 }
66575
66576
66577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66578   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66579   Dali::PanGesture *arg2 = 0 ;
66580
66581   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66582   arg2 = (Dali::PanGesture *)jarg2;
66583   if (!arg2) {
66584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66585     return ;
66586   }
66587   {
66588     try {
66589       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66590     } catch (std::out_of_range& e) {
66591       {
66592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66593       };
66594     } catch (std::exception& e) {
66595       {
66596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66597       };
66598     } catch (Dali::DaliException e) {
66599       {
66600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66601       };
66602     } catch (...) {
66603       {
66604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66605       };
66606     }
66607   }
66608
66609 }
66610
66611
66612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66613   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66614   Dali::TapGesture *arg2 = 0 ;
66615
66616   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66617   arg2 = (Dali::TapGesture *)jarg2;
66618   if (!arg2) {
66619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66620     return ;
66621   }
66622   {
66623     try {
66624       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66625     } catch (std::out_of_range& e) {
66626       {
66627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66628       };
66629     } catch (std::exception& e) {
66630       {
66631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66632       };
66633     } catch (Dali::DaliException e) {
66634       {
66635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66636       };
66637     } catch (...) {
66638       {
66639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66640       };
66641     }
66642   }
66643
66644 }
66645
66646
66647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66648   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66649   Dali::TapGesture *arg2 = 0 ;
66650
66651   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66652   arg2 = (Dali::TapGesture *)jarg2;
66653   if (!arg2) {
66654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66655     return ;
66656   }
66657   {
66658     try {
66659       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66660     } catch (std::out_of_range& e) {
66661       {
66662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66663       };
66664     } catch (std::exception& e) {
66665       {
66666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66667       };
66668     } catch (Dali::DaliException e) {
66669       {
66670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66671       };
66672     } catch (...) {
66673       {
66674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66675       };
66676     }
66677   }
66678
66679 }
66680
66681
66682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66683   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66684   Dali::LongPressGesture *arg2 = 0 ;
66685
66686   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66687   arg2 = (Dali::LongPressGesture *)jarg2;
66688   if (!arg2) {
66689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66690     return ;
66691   }
66692   {
66693     try {
66694       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66695     } catch (std::out_of_range& e) {
66696       {
66697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66698       };
66699     } catch (std::exception& e) {
66700       {
66701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66702       };
66703     } catch (Dali::DaliException e) {
66704       {
66705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66706       };
66707     } catch (...) {
66708       {
66709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66710       };
66711     }
66712   }
66713
66714 }
66715
66716
66717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66718   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66719   Dali::LongPressGesture *arg2 = 0 ;
66720
66721   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66722   arg2 = (Dali::LongPressGesture *)jarg2;
66723   if (!arg2) {
66724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66725     return ;
66726   }
66727   {
66728     try {
66729       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66730     } catch (std::out_of_range& e) {
66731       {
66732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66733       };
66734     } catch (std::exception& e) {
66735       {
66736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66737       };
66738     } catch (Dali::DaliException e) {
66739       {
66740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66741       };
66742     } catch (...) {
66743       {
66744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66745       };
66746     }
66747   }
66748
66749 }
66750
66751
66752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66753   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66754   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66755   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66756
66757   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66758   arg2 = (Dali::SlotObserver *)jarg2;
66759   arg3 = (Dali::CallbackBase *)jarg3;
66760   {
66761     try {
66762       (arg1)->SignalConnected(arg2,arg3);
66763     } catch (std::out_of_range& e) {
66764       {
66765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66766       };
66767     } catch (std::exception& e) {
66768       {
66769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66770       };
66771     } catch (Dali::DaliException e) {
66772       {
66773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66774       };
66775     } catch (...) {
66776       {
66777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66778       };
66779     }
66780   }
66781
66782 }
66783
66784
66785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66786   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66787   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66788   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66789
66790   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66791   arg2 = (Dali::SlotObserver *)jarg2;
66792   arg3 = (Dali::CallbackBase *)jarg3;
66793   {
66794     try {
66795       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
66796     } catch (std::out_of_range& e) {
66797       {
66798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66799       };
66800     } catch (std::exception& e) {
66801       {
66802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66803       };
66804     } catch (Dali::DaliException e) {
66805       {
66806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66807       };
66808     } catch (...) {
66809       {
66810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66811       };
66812     }
66813   }
66814
66815 }
66816
66817
66818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
66819   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66820   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66821   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66822
66823   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66824   arg2 = (Dali::SlotObserver *)jarg2;
66825   arg3 = (Dali::CallbackBase *)jarg3;
66826   {
66827     try {
66828       (arg1)->SignalDisconnected(arg2,arg3);
66829     } catch (std::out_of_range& e) {
66830       {
66831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66832       };
66833     } catch (std::exception& e) {
66834       {
66835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66836       };
66837     } catch (Dali::DaliException e) {
66838       {
66839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66840       };
66841     } catch (...) {
66842       {
66843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66844       };
66845     }
66846   }
66847
66848 }
66849
66850
66851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66852   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66853   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66854   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66855
66856   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66857   arg2 = (Dali::SlotObserver *)jarg2;
66858   arg3 = (Dali::CallbackBase *)jarg3;
66859   {
66860     try {
66861       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
66862     } catch (std::out_of_range& e) {
66863       {
66864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66865       };
66866     } catch (std::exception& e) {
66867       {
66868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66869       };
66870     } catch (Dali::DaliException e) {
66871       {
66872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66873       };
66874     } catch (...) {
66875       {
66876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66877       };
66878     }
66879   }
66880
66881 }
66882
66883
66884 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) {
66885   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
66886   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
66887   if (director) {
66888     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);
66889   }
66890 }
66891
66892
66893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
66894   void * jresult ;
66895   Dali::Toolkit::Control *arg1 = 0 ;
66896   Dali::Toolkit::Internal::Control *result = 0 ;
66897
66898   arg1 = (Dali::Toolkit::Control *)jarg1;
66899   if (!arg1) {
66900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66901     return 0;
66902   }
66903   {
66904     try {
66905       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
66906     } catch (std::out_of_range& e) {
66907       {
66908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66909       };
66910     } catch (std::exception& e) {
66911       {
66912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66913       };
66914     } catch (Dali::DaliException e) {
66915       {
66916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66917       };
66918     } catch (...) {
66919       {
66920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66921       };
66922     }
66923   }
66924
66925   jresult = (void *)result;
66926   return jresult;
66927 }
66928
66929
66930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
66931   int jresult ;
66932   int result;
66933
66934   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
66935   jresult = (int)result;
66936   return jresult;
66937 }
66938
66939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
66940   int jresult ;
66941   int result;
66942
66943   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
66944   jresult = (int)result;
66945   return jresult;
66946 }
66947
66948
66949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
66950   int jresult ;
66951   int result;
66952
66953   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
66954   jresult = (int)result;
66955   return jresult;
66956 }
66957
66958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
66959   int jresult ;
66960   int result;
66961
66962   result = (int)Dali::Toolkit::Control::Property::MARGIN;
66963   jresult = (int)result;
66964   return jresult;
66965 }
66966
66967
66968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
66969   int jresult ;
66970   int result;
66971
66972   result = (int)Dali::Toolkit::Control::Property::PADDING;
66973   jresult = (int)result;
66974   return jresult;
66975 }
66976
66977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
66978   void * jresult ;
66979   Dali::Toolkit::Control::Property *result = 0 ;
66980
66981   {
66982     try {
66983       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
66984     } catch (std::out_of_range& e) {
66985       {
66986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66987       };
66988     } catch (std::exception& e) {
66989       {
66990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66991       };
66992     } catch (Dali::DaliException e) {
66993       {
66994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66995       };
66996     } catch (...) {
66997       {
66998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66999       };
67000     }
67001   }
67002
67003   jresult = (void *)result;
67004   return jresult;
67005 }
67006
67007
67008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67009   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67010
67011   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67012   {
67013     try {
67014       delete arg1;
67015     } catch (std::out_of_range& e) {
67016       {
67017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67018       };
67019     } catch (std::exception& e) {
67020       {
67021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67022       };
67023     } catch (Dali::DaliException e) {
67024       {
67025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67026       };
67027     } catch (...) {
67028       {
67029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67030       };
67031     }
67032   }
67033
67034 }
67035
67036
67037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67038   void * jresult ;
67039   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67040
67041   {
67042     try {
67043       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67044     } catch (std::out_of_range& e) {
67045       {
67046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67047       };
67048     } catch (std::exception& e) {
67049       {
67050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67051       };
67052     } catch (Dali::DaliException e) {
67053       {
67054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67055       };
67056     } catch (...) {
67057       {
67058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67059       };
67060     }
67061   }
67062
67063   jresult = (void *)result;
67064   return jresult;
67065 }
67066
67067
67068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67069   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67070
67071   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67072   {
67073     try {
67074       delete arg1;
67075     } catch (std::out_of_range& e) {
67076       {
67077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67078       };
67079     } catch (std::exception& e) {
67080       {
67081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67082       };
67083     } catch (Dali::DaliException e) {
67084       {
67085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67086       };
67087     } catch (...) {
67088       {
67089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67090       };
67091     }
67092   }
67093
67094 }
67095
67096
67097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67098   void * jresult ;
67099   Dali::Toolkit::Control result;
67100
67101   {
67102     try {
67103       result = Dali::Toolkit::Control::New();
67104     } catch (std::out_of_range& e) {
67105       {
67106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67107       };
67108     } catch (std::exception& e) {
67109       {
67110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67111       };
67112     } catch (Dali::DaliException e) {
67113       {
67114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67115       };
67116     } catch (...) {
67117       {
67118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67119       };
67120     }
67121   }
67122
67123   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67124   return jresult;
67125 }
67126
67127
67128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67129   void * jresult ;
67130   Dali::Toolkit::Control *result = 0 ;
67131
67132   {
67133     try {
67134       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67135     } catch (std::out_of_range& e) {
67136       {
67137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67138       };
67139     } catch (std::exception& e) {
67140       {
67141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67142       };
67143     } catch (Dali::DaliException e) {
67144       {
67145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67146       };
67147     } catch (...) {
67148       {
67149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67150       };
67151     }
67152   }
67153
67154   jresult = (void *)result;
67155   return jresult;
67156 }
67157
67158
67159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67160   void * jresult ;
67161   Dali::Toolkit::Control *arg1 = 0 ;
67162   Dali::Toolkit::Control *result = 0 ;
67163
67164   arg1 = (Dali::Toolkit::Control *)jarg1;
67165   if (!arg1) {
67166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67167     return 0;
67168   }
67169   {
67170     try {
67171       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67172     } catch (std::out_of_range& e) {
67173       {
67174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67175       };
67176     } catch (std::exception& e) {
67177       {
67178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67179       };
67180     } catch (Dali::DaliException e) {
67181       {
67182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67183       };
67184     } catch (...) {
67185       {
67186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67187       };
67188     }
67189   }
67190
67191   jresult = (void *)result;
67192   return jresult;
67193 }
67194
67195
67196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67197   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67198
67199   arg1 = (Dali::Toolkit::Control *)jarg1;
67200   {
67201     try {
67202       delete arg1;
67203     } catch (std::out_of_range& e) {
67204       {
67205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67206       };
67207     } catch (std::exception& e) {
67208       {
67209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67210       };
67211     } catch (Dali::DaliException e) {
67212       {
67213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67214       };
67215     } catch (...) {
67216       {
67217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67218       };
67219     }
67220   }
67221
67222 }
67223
67224
67225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67226   void * jresult ;
67227   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67228   Dali::Toolkit::Control *arg2 = 0 ;
67229   Dali::Toolkit::Control *result = 0 ;
67230
67231   arg1 = (Dali::Toolkit::Control *)jarg1;
67232   arg2 = (Dali::Toolkit::Control *)jarg2;
67233   if (!arg2) {
67234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67235     return 0;
67236   }
67237   {
67238     try {
67239       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67240     } catch (std::out_of_range& e) {
67241       {
67242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67243       };
67244     } catch (std::exception& e) {
67245       {
67246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67247       };
67248     } catch (Dali::DaliException e) {
67249       {
67250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67251       };
67252     } catch (...) {
67253       {
67254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67255       };
67256     }
67257   }
67258
67259   jresult = (void *)result;
67260   return jresult;
67261 }
67262
67263
67264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67265   void * jresult ;
67266   Dali::BaseHandle arg1 ;
67267   Dali::BaseHandle *argp1 ;
67268   Dali::Toolkit::Control result;
67269
67270   argp1 = (Dali::BaseHandle *)jarg1;
67271   if (!argp1) {
67272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67273     return 0;
67274   }
67275   arg1 = *argp1;
67276   {
67277     try {
67278       result = Dali::Toolkit::Control::DownCast(arg1);
67279     } catch (std::out_of_range& e) {
67280       {
67281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67282       };
67283     } catch (std::exception& e) {
67284       {
67285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67286       };
67287     } catch (Dali::DaliException e) {
67288       {
67289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67290       };
67291     } catch (...) {
67292       {
67293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67294       };
67295     }
67296   }
67297
67298   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67299   return jresult;
67300 }
67301
67302
67303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67304   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67305
67306   arg1 = (Dali::Toolkit::Control *)jarg1;
67307   {
67308     try {
67309       (arg1)->SetKeyInputFocus();
67310     } catch (std::out_of_range& e) {
67311       {
67312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67313       };
67314     } catch (std::exception& e) {
67315       {
67316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67317       };
67318     } catch (Dali::DaliException e) {
67319       {
67320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67321       };
67322     } catch (...) {
67323       {
67324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67325       };
67326     }
67327   }
67328
67329 }
67330
67331
67332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67333   unsigned int jresult ;
67334   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67335   bool result;
67336
67337   arg1 = (Dali::Toolkit::Control *)jarg1;
67338   {
67339     try {
67340       result = (bool)(arg1)->HasKeyInputFocus();
67341     } catch (std::out_of_range& e) {
67342       {
67343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67344       };
67345     } catch (std::exception& e) {
67346       {
67347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67348       };
67349     } catch (Dali::DaliException e) {
67350       {
67351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67352       };
67353     } catch (...) {
67354       {
67355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67356       };
67357     }
67358   }
67359
67360   jresult = result;
67361   return jresult;
67362 }
67363
67364
67365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67366   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67367
67368   arg1 = (Dali::Toolkit::Control *)jarg1;
67369   {
67370     try {
67371       (arg1)->ClearKeyInputFocus();
67372     } catch (std::out_of_range& e) {
67373       {
67374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67375       };
67376     } catch (std::exception& e) {
67377       {
67378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67379       };
67380     } catch (Dali::DaliException e) {
67381       {
67382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67383       };
67384     } catch (...) {
67385       {
67386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67387       };
67388     }
67389   }
67390
67391 }
67392
67393
67394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67395   void * jresult ;
67396   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67397   Dali::PinchGestureDetector result;
67398
67399   arg1 = (Dali::Toolkit::Control *)jarg1;
67400   {
67401     try {
67402       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67403     } catch (std::out_of_range& e) {
67404       {
67405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67406       };
67407     } catch (std::exception& e) {
67408       {
67409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67410       };
67411     } catch (Dali::DaliException e) {
67412       {
67413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67414       };
67415     } catch (...) {
67416       {
67417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67418       };
67419     }
67420   }
67421
67422   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67423   return jresult;
67424 }
67425
67426
67427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67428   void * jresult ;
67429   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67430   Dali::PanGestureDetector result;
67431
67432   arg1 = (Dali::Toolkit::Control *)jarg1;
67433   {
67434     try {
67435       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67436     } catch (std::out_of_range& e) {
67437       {
67438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67439       };
67440     } catch (std::exception& e) {
67441       {
67442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67443       };
67444     } catch (Dali::DaliException e) {
67445       {
67446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67447       };
67448     } catch (...) {
67449       {
67450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67451       };
67452     }
67453   }
67454
67455   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67456   return jresult;
67457 }
67458
67459
67460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67461   void * jresult ;
67462   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67463   Dali::TapGestureDetector result;
67464
67465   arg1 = (Dali::Toolkit::Control *)jarg1;
67466   {
67467     try {
67468       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67469     } catch (std::out_of_range& e) {
67470       {
67471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67472       };
67473     } catch (std::exception& e) {
67474       {
67475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67476       };
67477     } catch (Dali::DaliException e) {
67478       {
67479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67480       };
67481     } catch (...) {
67482       {
67483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67484       };
67485     }
67486   }
67487
67488   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67489   return jresult;
67490 }
67491
67492
67493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67494   void * jresult ;
67495   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67496   Dali::LongPressGestureDetector result;
67497
67498   arg1 = (Dali::Toolkit::Control *)jarg1;
67499   {
67500     try {
67501       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67502     } catch (std::out_of_range& e) {
67503       {
67504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67505       };
67506     } catch (std::exception& e) {
67507       {
67508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67509       };
67510     } catch (Dali::DaliException e) {
67511       {
67512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67513       };
67514     } catch (...) {
67515       {
67516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67517       };
67518     }
67519   }
67520
67521   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67522   return jresult;
67523 }
67524
67525
67526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67527   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67528   std::string *arg2 = 0 ;
67529
67530   arg1 = (Dali::Toolkit::Control *)jarg1;
67531   if (!jarg2) {
67532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67533     return ;
67534   }
67535   std::string arg2_str(jarg2);
67536   arg2 = &arg2_str;
67537   {
67538     try {
67539       (arg1)->SetStyleName((std::string const &)*arg2);
67540     } catch (std::out_of_range& e) {
67541       {
67542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67543       };
67544     } catch (std::exception& e) {
67545       {
67546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67547       };
67548     } catch (Dali::DaliException e) {
67549       {
67550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67551       };
67552     } catch (...) {
67553       {
67554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67555       };
67556     }
67557   }
67558
67559
67560   //argout typemap for const std::string&
67561
67562 }
67563
67564
67565 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67566   char * jresult ;
67567   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67568   std::string *result = 0 ;
67569
67570   arg1 = (Dali::Toolkit::Control *)jarg1;
67571   {
67572     try {
67573       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67574     } catch (std::out_of_range& e) {
67575       {
67576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67577       };
67578     } catch (std::exception& e) {
67579       {
67580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67581       };
67582     } catch (Dali::DaliException e) {
67583       {
67584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67585       };
67586     } catch (...) {
67587       {
67588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67589       };
67590     }
67591   }
67592
67593   jresult = SWIG_csharp_string_callback(result->c_str());
67594   return jresult;
67595 }
67596
67597
67598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67599   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67600   Dali::Vector4 *arg2 = 0 ;
67601
67602   arg1 = (Dali::Toolkit::Control *)jarg1;
67603   arg2 = (Dali::Vector4 *)jarg2;
67604   if (!arg2) {
67605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67606     return ;
67607   }
67608   {
67609     try {
67610       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67611     } catch (std::out_of_range& e) {
67612       {
67613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67614       };
67615     } catch (std::exception& e) {
67616       {
67617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67618       };
67619     } catch (Dali::DaliException e) {
67620       {
67621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67622       };
67623     } catch (...) {
67624       {
67625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67626       };
67627     }
67628   }
67629
67630 }
67631
67632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67633   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67634
67635   arg1 = (Dali::Toolkit::Control *)jarg1;
67636   {
67637     try {
67638       (arg1)->ClearBackground();
67639     } catch (std::out_of_range& e) {
67640       {
67641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67642       };
67643     } catch (std::exception& e) {
67644       {
67645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67646       };
67647     } catch (Dali::DaliException e) {
67648       {
67649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67650       };
67651     } catch (...) {
67652       {
67653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67654       };
67655     }
67656   }
67657
67658 }
67659
67660
67661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67662   void * jresult ;
67663   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67664   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67665
67666   arg1 = (Dali::Toolkit::Control *)jarg1;
67667   {
67668     try {
67669       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67670     } catch (std::out_of_range& e) {
67671       {
67672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67673       };
67674     } catch (std::exception& e) {
67675       {
67676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67677       };
67678     } catch (Dali::DaliException e) {
67679       {
67680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67681       };
67682     } catch (...) {
67683       {
67684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67685       };
67686     }
67687   }
67688
67689   jresult = (void *)result;
67690   return jresult;
67691 }
67692
67693
67694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
67695   void * jresult ;
67696   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67697   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67698
67699   arg1 = (Dali::Toolkit::Control *)jarg1;
67700   {
67701     try {
67702       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
67703     } catch (std::out_of_range& e) {
67704       {
67705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67706       };
67707     } catch (std::exception& e) {
67708       {
67709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67710       };
67711     } catch (Dali::DaliException e) {
67712       {
67713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67714       };
67715     } catch (...) {
67716       {
67717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67718       };
67719     }
67720   }
67721
67722   jresult = (void *)result;
67723   return jresult;
67724 }
67725
67726
67727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
67728   void * jresult ;
67729   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67730   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67731
67732   arg1 = (Dali::Toolkit::Control *)jarg1;
67733   {
67734     try {
67735       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
67736     } catch (std::out_of_range& e) {
67737       {
67738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67739       };
67740     } catch (std::exception& e) {
67741       {
67742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67743       };
67744     } catch (Dali::DaliException e) {
67745       {
67746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67747       };
67748     } catch (...) {
67749       {
67750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67751       };
67752     }
67753   }
67754
67755   jresult = (void *)result;
67756   return jresult;
67757 }
67758
67759
67760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
67761   void * jresult ;
67762   Dali::Toolkit::Internal::Control *arg1 = 0 ;
67763   Dali::Toolkit::Control *result = 0 ;
67764
67765   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67766   if (!arg1) {
67767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
67768     return 0;
67769   }
67770   {
67771     try {
67772       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
67773     } catch (std::out_of_range& e) {
67774       {
67775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67776       };
67777     } catch (std::exception& e) {
67778       {
67779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67780       };
67781     } catch (Dali::DaliException e) {
67782       {
67783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67784       };
67785     } catch (...) {
67786       {
67787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67788       };
67789     }
67790   }
67791
67792   jresult = (void *)result;
67793   return jresult;
67794 }
67795
67796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
67797 {
67798   int jresult;
67799   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67800   arg1 = (Dali::Toolkit::Control *)jarg1;
67801
67802   if (!arg1) {
67803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67804     return 0;
67805   }
67806
67807   Dali::Property::Index arg2 = 0 ;
67808   arg2 = (Dali::Property::Index)jarg2;
67809
67810   Toolkit::Visual::ResourceStatus result;
67811   {
67812     try {
67813       result = arg1->GetVisualResourceStatus(arg2);
67814     } catch (std::out_of_range& e) {
67815       {
67816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67817       };
67818     } catch (std::exception& e) {
67819       {
67820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67821       };
67822     } catch (...) {
67823       {
67824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67825       };
67826     }
67827   }
67828   jresult = (int)(result);
67829   return jresult;
67830 }
67831
67832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
67833 {
67834   void * jresult;
67835   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67836   arg1 = (Dali::Toolkit::Control *)jarg1;
67837
67838   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
67839
67840   Dali::Toolkit::TransitionData *arg2 = 0 ;
67841   Dali::Animation result;
67842
67843   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
67844   if (!arg2) {
67845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
67846     return 0;
67847   }
67848   {
67849     try {
67850       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
67851     } catch (std::out_of_range& e) {
67852       {
67853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67854       };
67855     } catch (std::exception& e) {
67856       {
67857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67858       };
67859     } catch (Dali::DaliException e) {
67860       {
67861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67862       };
67863     } catch (...) {
67864       {
67865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67866       };
67867     }
67868   }
67869
67870   jresult = new Dali::Animation((const Dali::Animation &)result);
67871   return jresult;
67872 }
67873
67874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
67875 {
67876   Dali::Toolkit::Control arg1;
67877   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
67878
67879   if (!argp1) {
67880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67881   }
67882   arg1 = *argp1;
67883
67884   Dali::Property::Index arg2 = 0 ;
67885   arg2 = (Dali::Property::Index)jarg2;
67886
67887   Dali::Property::Index arg3 = 0 ;
67888   arg3 = (Dali::Property::Index)jarg3;
67889
67890   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
67891
67892   {
67893     try {
67894       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
67895     } catch (std::out_of_range& e) {
67896       {
67897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67898       };
67899     } catch (std::exception& e) {
67900       {
67901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67902       };
67903     } catch (...) {
67904       {
67905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67906       };
67907     }
67908   }
67909
67910
67911 }
67912
67913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
67914   void * jresult ;
67915   Dali::Toolkit::Control *arg1 = 0 ;
67916   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
67917
67918   arg1 = (Dali::Toolkit::Control *)jarg1;
67919   if (!arg1) {
67920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67921     return 0;
67922   }
67923   {
67924     try {
67925       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
67926     } catch (std::out_of_range& e) {
67927       {
67928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67929       };
67930     } catch (std::exception& e) {
67931       {
67932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67933       };
67934     } catch (Dali::DaliException e) {
67935       {
67936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67937       };
67938     } catch (...) {
67939       {
67940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67941       };
67942     }
67943   }
67944
67945   jresult = (void *)result;
67946   return jresult;
67947 }
67948
67949
67950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
67951   unsigned int jresult ;
67952   Dali::Toolkit::Control *arg1 = 0 ;
67953   bool result;
67954
67955   arg1 = (Dali::Toolkit::Control *)jarg1;
67956   if (!arg1) {
67957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67958     return 0;
67959   }
67960   {
67961     try {
67962       result = (bool)arg1->IsResourceReady();
67963     } catch (std::out_of_range& e) {
67964       {
67965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67966       };
67967     } catch (std::exception& e) {
67968       {
67969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67970       };
67971     } catch (Dali::DaliException e) {
67972       {
67973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67974       };
67975     } catch (...) {
67976       {
67977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67978       };
67979     }
67980   }
67981
67982   jresult = result;
67983   return jresult;
67984 }
67985
67986
67987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
67988   void * jresult ;
67989   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
67990
67991   {
67992     try {
67993       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
67994     } catch (std::out_of_range& e) {
67995       {
67996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67997       };
67998     } catch (std::exception& e) {
67999       {
68000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68001       };
68002     } catch (Dali::DaliException e) {
68003       {
68004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68005       };
68006     } catch (...) {
68007       {
68008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68009       };
68010     }
68011   }
68012
68013   jresult = (void *)result;
68014   return jresult;
68015 }
68016
68017
68018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68019   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68020
68021   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68022   {
68023     try {
68024       delete arg1;
68025     } catch (std::out_of_range& e) {
68026       {
68027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68028       };
68029     } catch (std::exception& e) {
68030       {
68031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68032       };
68033     } catch (Dali::DaliException e) {
68034       {
68035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68036       };
68037     } catch (...) {
68038       {
68039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68040       };
68041     }
68042   }
68043
68044 }
68045
68046
68047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68048   void * jresult ;
68049   Dali::Toolkit::KeyInputFocusManager result;
68050
68051   {
68052     try {
68053       result = Dali::Toolkit::KeyInputFocusManager::Get();
68054     } catch (std::out_of_range& e) {
68055       {
68056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68057       };
68058     } catch (std::exception& e) {
68059       {
68060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68061       };
68062     } catch (Dali::DaliException e) {
68063       {
68064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68065       };
68066     } catch (...) {
68067       {
68068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68069       };
68070     }
68071   }
68072
68073   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68074   return jresult;
68075 }
68076
68077
68078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68079   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68080   Dali::Toolkit::Control arg2 ;
68081   Dali::Toolkit::Control *argp2 ;
68082
68083   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68084   argp2 = (Dali::Toolkit::Control *)jarg2;
68085   if (!argp2) {
68086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68087     return ;
68088   }
68089   arg2 = *argp2;
68090   {
68091     try {
68092       (arg1)->SetFocus(arg2);
68093     } catch (std::out_of_range& e) {
68094       {
68095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68096       };
68097     } catch (std::exception& e) {
68098       {
68099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68100       };
68101     } catch (Dali::DaliException e) {
68102       {
68103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68104       };
68105     } catch (...) {
68106       {
68107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68108       };
68109     }
68110   }
68111
68112 }
68113
68114
68115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68116   void * jresult ;
68117   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68118   Dali::Toolkit::Control result;
68119
68120   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68121   {
68122     try {
68123       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68124     } catch (std::out_of_range& e) {
68125       {
68126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68127       };
68128     } catch (std::exception& e) {
68129       {
68130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68131       };
68132     } catch (Dali::DaliException e) {
68133       {
68134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68135       };
68136     } catch (...) {
68137       {
68138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68139       };
68140     }
68141   }
68142
68143   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68144   return jresult;
68145 }
68146
68147
68148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68149   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68150   Dali::Toolkit::Control arg2 ;
68151   Dali::Toolkit::Control *argp2 ;
68152
68153   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68154   argp2 = (Dali::Toolkit::Control *)jarg2;
68155   if (!argp2) {
68156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68157     return ;
68158   }
68159   arg2 = *argp2;
68160   {
68161     try {
68162       (arg1)->RemoveFocus(arg2);
68163     } catch (std::out_of_range& e) {
68164       {
68165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68166       };
68167     } catch (std::exception& e) {
68168       {
68169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68170       };
68171     } catch (Dali::DaliException e) {
68172       {
68173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68174       };
68175     } catch (...) {
68176       {
68177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68178       };
68179     }
68180   }
68181
68182 }
68183
68184
68185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68186   void * jresult ;
68187   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68188   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68189
68190   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68191   {
68192     try {
68193       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68194     } catch (std::out_of_range& e) {
68195       {
68196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68197       };
68198     } catch (std::exception& e) {
68199       {
68200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68201       };
68202     } catch (Dali::DaliException e) {
68203       {
68204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68205       };
68206     } catch (...) {
68207       {
68208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68209       };
68210     }
68211   }
68212
68213   jresult = (void *)result;
68214   return jresult;
68215 }
68216
68217
68218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68219   void * jresult ;
68220   Dali::Toolkit::Alignment::Padding *result = 0 ;
68221
68222   {
68223     try {
68224       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68225     } catch (std::out_of_range& e) {
68226       {
68227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68228       };
68229     } catch (std::exception& e) {
68230       {
68231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68232       };
68233     } catch (Dali::DaliException e) {
68234       {
68235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68236       };
68237     } catch (...) {
68238       {
68239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68240       };
68241     }
68242   }
68243
68244   jresult = (void *)result;
68245   return jresult;
68246 }
68247
68248
68249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68250   void * jresult ;
68251   float arg1 ;
68252   float arg2 ;
68253   float arg3 ;
68254   float arg4 ;
68255   Dali::Toolkit::Alignment::Padding *result = 0 ;
68256
68257   arg1 = (float)jarg1;
68258   arg2 = (float)jarg2;
68259   arg3 = (float)jarg3;
68260   arg4 = (float)jarg4;
68261   {
68262     try {
68263       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68264     } catch (std::out_of_range& e) {
68265       {
68266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68267       };
68268     } catch (std::exception& e) {
68269       {
68270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68271       };
68272     } catch (Dali::DaliException e) {
68273       {
68274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68275       };
68276     } catch (...) {
68277       {
68278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68279       };
68280     }
68281   }
68282
68283   jresult = (void *)result;
68284   return jresult;
68285 }
68286
68287
68288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68289   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68290   float arg2 ;
68291
68292   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68293   arg2 = (float)jarg2;
68294   if (arg1) (arg1)->left = arg2;
68295 }
68296
68297
68298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68299   float jresult ;
68300   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68301   float result;
68302
68303   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68304   result = (float) ((arg1)->left);
68305   jresult = result;
68306   return jresult;
68307 }
68308
68309
68310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68311   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68312   float arg2 ;
68313
68314   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68315   arg2 = (float)jarg2;
68316   if (arg1) (arg1)->right = arg2;
68317 }
68318
68319
68320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68321   float jresult ;
68322   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68323   float result;
68324
68325   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68326   result = (float) ((arg1)->right);
68327   jresult = result;
68328   return jresult;
68329 }
68330
68331
68332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68333   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68334   float arg2 ;
68335
68336   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68337   arg2 = (float)jarg2;
68338   if (arg1) (arg1)->top = arg2;
68339 }
68340
68341
68342 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68343   float jresult ;
68344   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68345   float result;
68346
68347   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68348   result = (float) ((arg1)->top);
68349   jresult = result;
68350   return jresult;
68351 }
68352
68353
68354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68355   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68356   float arg2 ;
68357
68358   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68359   arg2 = (float)jarg2;
68360   if (arg1) (arg1)->bottom = arg2;
68361 }
68362
68363
68364 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68365   float jresult ;
68366   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68367   float result;
68368
68369   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68370   result = (float) ((arg1)->bottom);
68371   jresult = result;
68372   return jresult;
68373 }
68374
68375
68376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68377   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68378
68379   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68380   {
68381     try {
68382       delete arg1;
68383     } catch (std::out_of_range& e) {
68384       {
68385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68386       };
68387     } catch (std::exception& e) {
68388       {
68389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68390       };
68391     } catch (Dali::DaliException e) {
68392       {
68393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68394       };
68395     } catch (...) {
68396       {
68397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68398       };
68399     }
68400   }
68401
68402 }
68403
68404
68405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68406   void * jresult ;
68407   Dali::Toolkit::Alignment *result = 0 ;
68408
68409   {
68410     try {
68411       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68412     } catch (std::out_of_range& e) {
68413       {
68414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68415       };
68416     } catch (std::exception& e) {
68417       {
68418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68419       };
68420     } catch (Dali::DaliException e) {
68421       {
68422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68423       };
68424     } catch (...) {
68425       {
68426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68427       };
68428     }
68429   }
68430
68431   jresult = (void *)result;
68432   return jresult;
68433 }
68434
68435
68436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68437   void * jresult ;
68438   Dali::Toolkit::Alignment::Type arg1 ;
68439   Dali::Toolkit::Alignment::Type arg2 ;
68440   Dali::Toolkit::Alignment result;
68441
68442   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68443   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68444   {
68445     try {
68446       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68447     } catch (std::out_of_range& e) {
68448       {
68449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68450       };
68451     } catch (std::exception& e) {
68452       {
68453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68454       };
68455     } catch (Dali::DaliException e) {
68456       {
68457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68458       };
68459     } catch (...) {
68460       {
68461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68462       };
68463     }
68464   }
68465
68466   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68467   return jresult;
68468 }
68469
68470
68471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68472   void * jresult ;
68473   Dali::Toolkit::Alignment::Type arg1 ;
68474   Dali::Toolkit::Alignment result;
68475
68476   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68477   {
68478     try {
68479       result = Dali::Toolkit::Alignment::New(arg1);
68480     } catch (std::out_of_range& e) {
68481       {
68482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68483       };
68484     } catch (std::exception& e) {
68485       {
68486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68487       };
68488     } catch (Dali::DaliException e) {
68489       {
68490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68491       };
68492     } catch (...) {
68493       {
68494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68495       };
68496     }
68497   }
68498
68499   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68500   return jresult;
68501 }
68502
68503
68504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68505   void * jresult ;
68506   Dali::Toolkit::Alignment result;
68507
68508   {
68509     try {
68510       result = Dali::Toolkit::Alignment::New();
68511     } catch (std::out_of_range& e) {
68512       {
68513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68514       };
68515     } catch (std::exception& e) {
68516       {
68517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68518       };
68519     } catch (Dali::DaliException e) {
68520       {
68521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68522       };
68523     } catch (...) {
68524       {
68525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68526       };
68527     }
68528   }
68529
68530   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68531   return jresult;
68532 }
68533
68534
68535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68536   void * jresult ;
68537   Dali::Toolkit::Alignment *arg1 = 0 ;
68538   Dali::Toolkit::Alignment *result = 0 ;
68539
68540   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68541   if (!arg1) {
68542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68543     return 0;
68544   }
68545   {
68546     try {
68547       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68548     } catch (std::out_of_range& e) {
68549       {
68550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68551       };
68552     } catch (std::exception& e) {
68553       {
68554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68555       };
68556     } catch (Dali::DaliException e) {
68557       {
68558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68559       };
68560     } catch (...) {
68561       {
68562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68563       };
68564     }
68565   }
68566
68567   jresult = (void *)result;
68568   return jresult;
68569 }
68570
68571
68572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68573   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68574
68575   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68576   {
68577     try {
68578       delete arg1;
68579     } catch (std::out_of_range& e) {
68580       {
68581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68582       };
68583     } catch (std::exception& e) {
68584       {
68585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68586       };
68587     } catch (Dali::DaliException e) {
68588       {
68589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68590       };
68591     } catch (...) {
68592       {
68593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68594       };
68595     }
68596   }
68597
68598 }
68599
68600
68601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68602   void * jresult ;
68603   Dali::BaseHandle arg1 ;
68604   Dali::BaseHandle *argp1 ;
68605   Dali::Toolkit::Alignment result;
68606
68607   argp1 = (Dali::BaseHandle *)jarg1;
68608   if (!argp1) {
68609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68610     return 0;
68611   }
68612   arg1 = *argp1;
68613   {
68614     try {
68615       result = Dali::Toolkit::Alignment::DownCast(arg1);
68616     } catch (std::out_of_range& e) {
68617       {
68618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68619       };
68620     } catch (std::exception& e) {
68621       {
68622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68623       };
68624     } catch (Dali::DaliException e) {
68625       {
68626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68627       };
68628     } catch (...) {
68629       {
68630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68631       };
68632     }
68633   }
68634
68635   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68636   return jresult;
68637 }
68638
68639
68640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68641   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68642   Dali::Toolkit::Alignment::Type arg2 ;
68643
68644   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68645   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68646   {
68647     try {
68648       (arg1)->SetAlignmentType(arg2);
68649     } catch (std::out_of_range& e) {
68650       {
68651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68652       };
68653     } catch (std::exception& e) {
68654       {
68655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68656       };
68657     } catch (Dali::DaliException e) {
68658       {
68659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68660       };
68661     } catch (...) {
68662       {
68663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68664       };
68665     }
68666   }
68667
68668 }
68669
68670
68671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68672   int jresult ;
68673   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68674   Dali::Toolkit::Alignment::Type result;
68675
68676   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68677   {
68678     try {
68679       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
68680     } catch (std::out_of_range& e) {
68681       {
68682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68683       };
68684     } catch (std::exception& e) {
68685       {
68686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68687       };
68688     } catch (Dali::DaliException e) {
68689       {
68690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68691       };
68692     } catch (...) {
68693       {
68694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68695       };
68696     }
68697   }
68698
68699   jresult = (int)result;
68700   return jresult;
68701 }
68702
68703
68704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
68705   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68706   Dali::Toolkit::Alignment::Scaling arg2 ;
68707
68708   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68709   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
68710   {
68711     try {
68712       (arg1)->SetScaling(arg2);
68713     } catch (std::out_of_range& e) {
68714       {
68715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68716       };
68717     } catch (std::exception& e) {
68718       {
68719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68720       };
68721     } catch (Dali::DaliException e) {
68722       {
68723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68724       };
68725     } catch (...) {
68726       {
68727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68728       };
68729     }
68730   }
68731
68732 }
68733
68734
68735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
68736   int jresult ;
68737   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68738   Dali::Toolkit::Alignment::Scaling result;
68739
68740   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68741   {
68742     try {
68743       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
68744     } catch (std::out_of_range& e) {
68745       {
68746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68747       };
68748     } catch (std::exception& e) {
68749       {
68750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68751       };
68752     } catch (Dali::DaliException e) {
68753       {
68754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68755       };
68756     } catch (...) {
68757       {
68758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68759       };
68760     }
68761   }
68762
68763   jresult = (int)result;
68764   return jresult;
68765 }
68766
68767
68768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
68769   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68770   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
68771
68772   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68773   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
68774   if (!arg2) {
68775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
68776     return ;
68777   }
68778   {
68779     try {
68780       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
68781     } catch (std::out_of_range& e) {
68782       {
68783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68784       };
68785     } catch (std::exception& e) {
68786       {
68787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68788       };
68789     } catch (Dali::DaliException e) {
68790       {
68791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68792       };
68793     } catch (...) {
68794       {
68795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68796       };
68797     }
68798   }
68799
68800 }
68801
68802
68803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
68804   void * jresult ;
68805   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68806   Dali::Toolkit::Alignment::Padding *result = 0 ;
68807
68808   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68809   {
68810     try {
68811       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
68812     } catch (std::out_of_range& e) {
68813       {
68814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68815       };
68816     } catch (std::exception& e) {
68817       {
68818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68819       };
68820     } catch (Dali::DaliException e) {
68821       {
68822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68823       };
68824     } catch (...) {
68825       {
68826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68827       };
68828     }
68829   }
68830
68831   jresult = (void *)result;
68832   return jresult;
68833 }
68834
68835
68836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
68837   void * jresult ;
68838   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68839   Dali::Toolkit::Alignment *arg2 = 0 ;
68840   Dali::Toolkit::Alignment *result = 0 ;
68841
68842   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68843   arg2 = (Dali::Toolkit::Alignment *)jarg2;
68844   if (!arg2) {
68845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68846     return 0;
68847   }
68848   {
68849     try {
68850       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
68851     } catch (std::out_of_range& e) {
68852       {
68853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68854       };
68855     } catch (std::exception& e) {
68856       {
68857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68858       };
68859     } catch (Dali::DaliException e) {
68860       {
68861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68862       };
68863     } catch (...) {
68864       {
68865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68866       };
68867     }
68868   }
68869
68870   jresult = (void *)result;
68871   return jresult;
68872 }
68873
68874
68875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
68876   int jresult ;
68877   int result;
68878
68879   result = (int)Dali::Toolkit::Button::Property::DISABLED;
68880   jresult = (int)result;
68881   return jresult;
68882 }
68883
68884
68885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
68886   int jresult ;
68887   int result;
68888
68889   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
68890   jresult = (int)result;
68891   return jresult;
68892 }
68893
68894
68895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
68896   int jresult ;
68897   int result;
68898
68899   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
68900   jresult = (int)result;
68901   return jresult;
68902 }
68903
68904
68905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
68906   int jresult ;
68907   int result;
68908
68909   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
68910   jresult = (int)result;
68911   return jresult;
68912 }
68913
68914
68915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
68916   int jresult ;
68917   int result;
68918
68919   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
68920   jresult = (int)result;
68921   return jresult;
68922 }
68923
68924
68925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
68926   int jresult ;
68927   int result;
68928
68929   result = (int)Dali::Toolkit::Button::Property::SELECTED;
68930   jresult = (int)result;
68931   return jresult;
68932 }
68933
68934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
68935   int jresult ;
68936   int result;
68937
68938   result = (int)Dali::Toolkit::Button::Property::LABEL;
68939   jresult = (int)result;
68940   return jresult;
68941 }
68942
68943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
68944   void * jresult ;
68945   Dali::Toolkit::Button::Property *result = 0 ;
68946
68947   {
68948     try {
68949       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
68950     } catch (std::out_of_range& e) {
68951       {
68952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68953       };
68954     } catch (std::exception& e) {
68955       {
68956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68957       };
68958     } catch (Dali::DaliException e) {
68959       {
68960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68961       };
68962     } catch (...) {
68963       {
68964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68965       };
68966     }
68967   }
68968
68969   jresult = (void *)result;
68970   return jresult;
68971 }
68972
68973
68974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
68975   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
68976
68977   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
68978   {
68979     try {
68980       delete arg1;
68981     } catch (std::out_of_range& e) {
68982       {
68983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68984       };
68985     } catch (std::exception& e) {
68986       {
68987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68988       };
68989     } catch (Dali::DaliException e) {
68990       {
68991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68992       };
68993     } catch (...) {
68994       {
68995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68996       };
68997     }
68998   }
68999
69000 }
69001
69002
69003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69004   void * jresult ;
69005   Dali::Toolkit::Button *result = 0 ;
69006
69007   {
69008     try {
69009       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69010     } catch (std::out_of_range& e) {
69011       {
69012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69013       };
69014     } catch (std::exception& e) {
69015       {
69016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69017       };
69018     } catch (Dali::DaliException e) {
69019       {
69020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69021       };
69022     } catch (...) {
69023       {
69024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69025       };
69026     }
69027   }
69028
69029   jresult = (void *)result;
69030   return jresult;
69031 }
69032
69033
69034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69035   void * jresult ;
69036   Dali::Toolkit::Button *arg1 = 0 ;
69037   Dali::Toolkit::Button *result = 0 ;
69038
69039   arg1 = (Dali::Toolkit::Button *)jarg1;
69040   if (!arg1) {
69041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69042     return 0;
69043   }
69044   {
69045     try {
69046       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69047     } catch (std::out_of_range& e) {
69048       {
69049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69050       };
69051     } catch (std::exception& e) {
69052       {
69053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69054       };
69055     } catch (Dali::DaliException e) {
69056       {
69057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69058       };
69059     } catch (...) {
69060       {
69061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69062       };
69063     }
69064   }
69065
69066   jresult = (void *)result;
69067   return jresult;
69068 }
69069
69070
69071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69072   void * jresult ;
69073   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69074   Dali::Toolkit::Button *arg2 = 0 ;
69075   Dali::Toolkit::Button *result = 0 ;
69076
69077   arg1 = (Dali::Toolkit::Button *)jarg1;
69078   arg2 = (Dali::Toolkit::Button *)jarg2;
69079   if (!arg2) {
69080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69081     return 0;
69082   }
69083   {
69084     try {
69085       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69086     } catch (std::out_of_range& e) {
69087       {
69088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69089       };
69090     } catch (std::exception& e) {
69091       {
69092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69093       };
69094     } catch (Dali::DaliException e) {
69095       {
69096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69097       };
69098     } catch (...) {
69099       {
69100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69101       };
69102     }
69103   }
69104
69105   jresult = (void *)result;
69106   return jresult;
69107 }
69108
69109
69110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69111   void * jresult ;
69112   Dali::BaseHandle arg1 ;
69113   Dali::BaseHandle *argp1 ;
69114   Dali::Toolkit::Button result;
69115
69116   argp1 = (Dali::BaseHandle *)jarg1;
69117   if (!argp1) {
69118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69119     return 0;
69120   }
69121   arg1 = *argp1;
69122   {
69123     try {
69124       result = Dali::Toolkit::Button::DownCast(arg1);
69125     } catch (std::out_of_range& e) {
69126       {
69127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69128       };
69129     } catch (std::exception& e) {
69130       {
69131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69132       };
69133     } catch (Dali::DaliException e) {
69134       {
69135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69136       };
69137     } catch (...) {
69138       {
69139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69140       };
69141     }
69142   }
69143
69144   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69145   return jresult;
69146 }
69147
69148
69149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69150   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69151
69152   arg1 = (Dali::Toolkit::Button *)jarg1;
69153   {
69154     try {
69155       delete arg1;
69156     } catch (std::out_of_range& e) {
69157       {
69158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69159       };
69160     } catch (std::exception& e) {
69161       {
69162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69163       };
69164     } catch (Dali::DaliException e) {
69165       {
69166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69167       };
69168     } catch (...) {
69169       {
69170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69171       };
69172     }
69173   }
69174
69175 }
69176
69177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69178   void * jresult ;
69179   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69180   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69181
69182   arg1 = (Dali::Toolkit::Button *)jarg1;
69183   {
69184     try {
69185       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69186     } catch (std::out_of_range& e) {
69187       {
69188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69189       };
69190     } catch (std::exception& e) {
69191       {
69192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69193       };
69194     } catch (Dali::DaliException e) {
69195       {
69196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69197       };
69198     } catch (...) {
69199       {
69200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69201       };
69202     }
69203   }
69204
69205   jresult = (void *)result;
69206   return jresult;
69207 }
69208
69209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
69210   void * jresult ;
69211   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69212   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69213
69214   arg1 = (Dali::Toolkit::Button *)jarg1;
69215   {
69216     try {
69217       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
69218     } catch (std::out_of_range& e) {
69219       {
69220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69221       };
69222     } catch (std::exception& e) {
69223       {
69224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69225       };
69226     } catch (Dali::DaliException e) {
69227       {
69228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69229       };
69230     } catch (...) {
69231       {
69232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69233       };
69234     }
69235   }
69236
69237   jresult = (void *)result;
69238   return jresult;
69239 }
69240
69241
69242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
69243   void * jresult ;
69244   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69245   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69246
69247   arg1 = (Dali::Toolkit::Button *)jarg1;
69248   {
69249     try {
69250       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
69251     } catch (std::out_of_range& e) {
69252       {
69253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69254       };
69255     } catch (std::exception& e) {
69256       {
69257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69258       };
69259     } catch (Dali::DaliException e) {
69260       {
69261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69262       };
69263     } catch (...) {
69264       {
69265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69266       };
69267     }
69268   }
69269
69270   jresult = (void *)result;
69271   return jresult;
69272 }
69273
69274
69275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
69276   void * jresult ;
69277   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69278   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69279
69280   arg1 = (Dali::Toolkit::Button *)jarg1;
69281   {
69282     try {
69283       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
69284     } catch (std::out_of_range& e) {
69285       {
69286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69287       };
69288     } catch (std::exception& e) {
69289       {
69290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69291       };
69292     } catch (Dali::DaliException e) {
69293       {
69294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69295       };
69296     } catch (...) {
69297       {
69298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69299       };
69300     }
69301   }
69302
69303   jresult = (void *)result;
69304   return jresult;
69305 }
69306
69307
69308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
69309   void * jresult ;
69310   Dali::Toolkit::CheckBoxButton *result = 0 ;
69311
69312   {
69313     try {
69314       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
69315     } catch (std::out_of_range& e) {
69316       {
69317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69318       };
69319     } catch (std::exception& e) {
69320       {
69321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69322       };
69323     } catch (Dali::DaliException e) {
69324       {
69325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69326       };
69327     } catch (...) {
69328       {
69329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69330       };
69331     }
69332   }
69333
69334   jresult = (void *)result;
69335   return jresult;
69336 }
69337
69338
69339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
69340   void * jresult ;
69341   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
69342   Dali::Toolkit::CheckBoxButton *result = 0 ;
69343
69344   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69345   if (!arg1) {
69346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69347     return 0;
69348   }
69349   {
69350     try {
69351       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
69352     } catch (std::out_of_range& e) {
69353       {
69354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69355       };
69356     } catch (std::exception& e) {
69357       {
69358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69359       };
69360     } catch (Dali::DaliException e) {
69361       {
69362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69363       };
69364     } catch (...) {
69365       {
69366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69367       };
69368     }
69369   }
69370
69371   jresult = (void *)result;
69372   return jresult;
69373 }
69374
69375
69376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
69377   void * jresult ;
69378   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69379   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
69380   Dali::Toolkit::CheckBoxButton *result = 0 ;
69381
69382   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69383   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
69384   if (!arg2) {
69385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69386     return 0;
69387   }
69388   {
69389     try {
69390       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
69391     } catch (std::out_of_range& e) {
69392       {
69393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69394       };
69395     } catch (std::exception& e) {
69396       {
69397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69398       };
69399     } catch (Dali::DaliException e) {
69400       {
69401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69402       };
69403     } catch (...) {
69404       {
69405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69406       };
69407     }
69408   }
69409
69410   jresult = (void *)result;
69411   return jresult;
69412 }
69413
69414
69415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
69416   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69417
69418   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69419   {
69420     try {
69421       delete arg1;
69422     } catch (std::out_of_range& e) {
69423       {
69424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69425       };
69426     } catch (std::exception& e) {
69427       {
69428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69429       };
69430     } catch (Dali::DaliException e) {
69431       {
69432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69433       };
69434     } catch (...) {
69435       {
69436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69437       };
69438     }
69439   }
69440
69441 }
69442
69443
69444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
69445   void * jresult ;
69446   Dali::Toolkit::CheckBoxButton result;
69447
69448   {
69449     try {
69450       result = Dali::Toolkit::CheckBoxButton::New();
69451     } catch (std::out_of_range& e) {
69452       {
69453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69454       };
69455     } catch (std::exception& e) {
69456       {
69457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69458       };
69459     } catch (Dali::DaliException e) {
69460       {
69461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69462       };
69463     } catch (...) {
69464       {
69465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69466       };
69467     }
69468   }
69469
69470   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69471   return jresult;
69472 }
69473
69474
69475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
69476   void * jresult ;
69477   Dali::BaseHandle arg1 ;
69478   Dali::BaseHandle *argp1 ;
69479   Dali::Toolkit::CheckBoxButton result;
69480
69481   argp1 = (Dali::BaseHandle *)jarg1;
69482   if (!argp1) {
69483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69484     return 0;
69485   }
69486   arg1 = *argp1;
69487   {
69488     try {
69489       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
69490     } catch (std::out_of_range& e) {
69491       {
69492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69493       };
69494     } catch (std::exception& e) {
69495       {
69496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69497       };
69498     } catch (Dali::DaliException e) {
69499       {
69500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69501       };
69502     } catch (...) {
69503       {
69504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69505       };
69506     }
69507   }
69508
69509   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69510   return jresult;
69511 }
69512
69513
69514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
69515   int jresult ;
69516   int result;
69517
69518   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
69519   jresult = (int)result;
69520   return jresult;
69521 }
69522
69523
69524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
69525   int jresult ;
69526   int result;
69527
69528   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
69529   jresult = (int)result;
69530   return jresult;
69531 }
69532
69533
69534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
69535   int jresult ;
69536   int result;
69537
69538   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
69539   jresult = (int)result;
69540   return jresult;
69541 }
69542
69543
69544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
69545   int jresult ;
69546   int result;
69547
69548   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
69549   jresult = (int)result;
69550   return jresult;
69551 }
69552
69553
69554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
69555   int jresult ;
69556   int result;
69557
69558   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
69559   jresult = (int)result;
69560   return jresult;
69561 }
69562
69563
69564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
69565   void * jresult ;
69566   Dali::Toolkit::PushButton::Property *result = 0 ;
69567
69568   {
69569     try {
69570       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
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 = (void *)result;
69591   return jresult;
69592 }
69593
69594
69595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
69596   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
69597
69598   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
69599   {
69600     try {
69601       delete arg1;
69602     } catch (std::out_of_range& e) {
69603       {
69604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69605       };
69606     } catch (std::exception& e) {
69607       {
69608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69609       };
69610     } catch (Dali::DaliException e) {
69611       {
69612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69613       };
69614     } catch (...) {
69615       {
69616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69617       };
69618     }
69619   }
69620
69621 }
69622
69623
69624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
69625   void * jresult ;
69626   Dali::Toolkit::PushButton *result = 0 ;
69627
69628   {
69629     try {
69630       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
69631     } catch (std::out_of_range& e) {
69632       {
69633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69634       };
69635     } catch (std::exception& e) {
69636       {
69637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69638       };
69639     } catch (Dali::DaliException e) {
69640       {
69641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69642       };
69643     } catch (...) {
69644       {
69645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69646       };
69647     }
69648   }
69649
69650   jresult = (void *)result;
69651   return jresult;
69652 }
69653
69654
69655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
69656   void * jresult ;
69657   Dali::Toolkit::PushButton *arg1 = 0 ;
69658   Dali::Toolkit::PushButton *result = 0 ;
69659
69660   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69661   if (!arg1) {
69662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69663     return 0;
69664   }
69665   {
69666     try {
69667       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
69668     } catch (std::out_of_range& e) {
69669       {
69670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69671       };
69672     } catch (std::exception& e) {
69673       {
69674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69675       };
69676     } catch (Dali::DaliException e) {
69677       {
69678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69679       };
69680     } catch (...) {
69681       {
69682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69683       };
69684     }
69685   }
69686
69687   jresult = (void *)result;
69688   return jresult;
69689 }
69690
69691
69692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
69693   void * jresult ;
69694   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69695   Dali::Toolkit::PushButton *arg2 = 0 ;
69696   Dali::Toolkit::PushButton *result = 0 ;
69697
69698   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69699   arg2 = (Dali::Toolkit::PushButton *)jarg2;
69700   if (!arg2) {
69701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69702     return 0;
69703   }
69704   {
69705     try {
69706       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
69707     } catch (std::out_of_range& e) {
69708       {
69709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69710       };
69711     } catch (std::exception& e) {
69712       {
69713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69714       };
69715     } catch (Dali::DaliException e) {
69716       {
69717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69718       };
69719     } catch (...) {
69720       {
69721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69722       };
69723     }
69724   }
69725
69726   jresult = (void *)result;
69727   return jresult;
69728 }
69729
69730
69731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
69732   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69733
69734   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69735   {
69736     try {
69737       delete arg1;
69738     } catch (std::out_of_range& e) {
69739       {
69740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69741       };
69742     } catch (std::exception& e) {
69743       {
69744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69745       };
69746     } catch (Dali::DaliException e) {
69747       {
69748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69749       };
69750     } catch (...) {
69751       {
69752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69753       };
69754     }
69755   }
69756
69757 }
69758
69759
69760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
69761   void * jresult ;
69762   Dali::Toolkit::PushButton result;
69763
69764   {
69765     try {
69766       result = Dali::Toolkit::PushButton::New();
69767     } catch (std::out_of_range& e) {
69768       {
69769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69770       };
69771     } catch (std::exception& e) {
69772       {
69773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69774       };
69775     } catch (Dali::DaliException e) {
69776       {
69777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69778       };
69779     } catch (...) {
69780       {
69781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69782       };
69783     }
69784   }
69785
69786   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69787   return jresult;
69788 }
69789
69790
69791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
69792   void * jresult ;
69793   Dali::BaseHandle arg1 ;
69794   Dali::BaseHandle *argp1 ;
69795   Dali::Toolkit::PushButton result;
69796
69797   argp1 = (Dali::BaseHandle *)jarg1;
69798   if (!argp1) {
69799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69800     return 0;
69801   }
69802   arg1 = *argp1;
69803   {
69804     try {
69805       result = Dali::Toolkit::PushButton::DownCast(arg1);
69806     } catch (std::out_of_range& e) {
69807       {
69808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69809       };
69810     } catch (std::exception& e) {
69811       {
69812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69813       };
69814     } catch (Dali::DaliException e) {
69815       {
69816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69817       };
69818     } catch (...) {
69819       {
69820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69821       };
69822     }
69823   }
69824
69825   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69826   return jresult;
69827 }
69828
69829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
69830   void * jresult ;
69831   Dali::Toolkit::RadioButton *result = 0 ;
69832
69833   {
69834     try {
69835       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
69836     } catch (std::out_of_range& e) {
69837       {
69838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69839       };
69840     } catch (std::exception& e) {
69841       {
69842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69843       };
69844     } catch (Dali::DaliException e) {
69845       {
69846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69847       };
69848     } catch (...) {
69849       {
69850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69851       };
69852     }
69853   }
69854
69855   jresult = (void *)result;
69856   return jresult;
69857 }
69858
69859
69860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
69861   void * jresult ;
69862   Dali::Toolkit::RadioButton *arg1 = 0 ;
69863   Dali::Toolkit::RadioButton *result = 0 ;
69864
69865   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69866   if (!arg1) {
69867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69868     return 0;
69869   }
69870   {
69871     try {
69872       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
69873     } catch (std::out_of_range& e) {
69874       {
69875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69876       };
69877     } catch (std::exception& e) {
69878       {
69879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69880       };
69881     } catch (Dali::DaliException e) {
69882       {
69883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69884       };
69885     } catch (...) {
69886       {
69887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69888       };
69889     }
69890   }
69891
69892   jresult = (void *)result;
69893   return jresult;
69894 }
69895
69896
69897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
69898   void * jresult ;
69899   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
69900   Dali::Toolkit::RadioButton *arg2 = 0 ;
69901   Dali::Toolkit::RadioButton *result = 0 ;
69902
69903   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69904   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
69905   if (!arg2) {
69906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69907     return 0;
69908   }
69909   {
69910     try {
69911       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
69912     } catch (std::out_of_range& e) {
69913       {
69914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69915       };
69916     } catch (std::exception& e) {
69917       {
69918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69919       };
69920     } catch (Dali::DaliException e) {
69921       {
69922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69923       };
69924     } catch (...) {
69925       {
69926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69927       };
69928     }
69929   }
69930
69931   jresult = (void *)result;
69932   return jresult;
69933 }
69934
69935
69936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
69937   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
69938
69939   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69940   {
69941     try {
69942       delete arg1;
69943     } catch (std::out_of_range& e) {
69944       {
69945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69946       };
69947     } catch (std::exception& e) {
69948       {
69949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69950       };
69951     } catch (Dali::DaliException e) {
69952       {
69953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69954       };
69955     } catch (...) {
69956       {
69957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69958       };
69959     }
69960   }
69961
69962 }
69963
69964
69965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
69966   void * jresult ;
69967   Dali::Toolkit::RadioButton result;
69968
69969   {
69970     try {
69971       result = Dali::Toolkit::RadioButton::New();
69972     } catch (std::out_of_range& e) {
69973       {
69974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69975       };
69976     } catch (std::exception& e) {
69977       {
69978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69979       };
69980     } catch (Dali::DaliException e) {
69981       {
69982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69983       };
69984     } catch (...) {
69985       {
69986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69987       };
69988     }
69989   }
69990
69991   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
69992   return jresult;
69993 }
69994
69995
69996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
69997   void * jresult ;
69998   std::string *arg1 = 0 ;
69999   Dali::Toolkit::RadioButton result;
70000
70001   if (!jarg1) {
70002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70003     return 0;
70004   }
70005   std::string arg1_str(jarg1);
70006   arg1 = &arg1_str;
70007   {
70008     try {
70009       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
70010     } catch (std::out_of_range& e) {
70011       {
70012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70013       };
70014     } catch (std::exception& e) {
70015       {
70016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70017       };
70018     } catch (Dali::DaliException e) {
70019       {
70020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70021       };
70022     } catch (...) {
70023       {
70024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70025       };
70026     }
70027   }
70028
70029   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70030
70031   //argout typemap for const std::string&
70032
70033   return jresult;
70034 }
70035
70036
70037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
70038   void * jresult ;
70039   Dali::BaseHandle arg1 ;
70040   Dali::BaseHandle *argp1 ;
70041   Dali::Toolkit::RadioButton result;
70042
70043   argp1 = (Dali::BaseHandle *)jarg1;
70044   if (!argp1) {
70045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70046     return 0;
70047   }
70048   arg1 = *argp1;
70049   {
70050     try {
70051       result = Dali::Toolkit::RadioButton::DownCast(arg1);
70052     } catch (std::out_of_range& e) {
70053       {
70054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70055       };
70056     } catch (std::exception& e) {
70057       {
70058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70059       };
70060     } catch (Dali::DaliException e) {
70061       {
70062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70063       };
70064     } catch (...) {
70065       {
70066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70067       };
70068     }
70069   }
70070
70071   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70072   return jresult;
70073 }
70074
70075
70076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
70077   int jresult ;
70078   int result;
70079
70080   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
70081   jresult = (int)result;
70082   return jresult;
70083 }
70084
70085
70086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
70087   int jresult ;
70088   int result;
70089
70090   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
70091   jresult = (int)result;
70092   return jresult;
70093 }
70094
70095
70096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
70097   int jresult ;
70098   int result;
70099
70100   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
70101   jresult = (int)result;
70102   return jresult;
70103 }
70104
70105
70106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
70107   int jresult ;
70108   int result;
70109
70110   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
70111   jresult = (int)result;
70112   return jresult;
70113 }
70114
70115
70116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
70117   int jresult ;
70118   int result;
70119
70120   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
70121   jresult = (int)result;
70122   return jresult;
70123 }
70124
70125
70126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
70127   int jresult ;
70128   int result;
70129
70130   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
70131   jresult = (int)result;
70132   return jresult;
70133 }
70134
70135
70136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
70137   void * jresult ;
70138   Dali::Toolkit::FlexContainer::Property *result = 0 ;
70139
70140   {
70141     try {
70142       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
70143     } catch (std::out_of_range& e) {
70144       {
70145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70146       };
70147     } catch (std::exception& e) {
70148       {
70149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70150       };
70151     } catch (Dali::DaliException e) {
70152       {
70153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70154       };
70155     } catch (...) {
70156       {
70157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70158       };
70159     }
70160   }
70161
70162   jresult = (void *)result;
70163   return jresult;
70164 }
70165
70166
70167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
70168   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
70169
70170   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
70171   {
70172     try {
70173       delete arg1;
70174     } catch (std::out_of_range& e) {
70175       {
70176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70177       };
70178     } catch (std::exception& e) {
70179       {
70180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70181       };
70182     } catch (Dali::DaliException e) {
70183       {
70184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70185       };
70186     } catch (...) {
70187       {
70188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70189       };
70190     }
70191   }
70192
70193 }
70194
70195
70196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
70197   int jresult ;
70198   int result;
70199
70200   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
70201   jresult = (int)result;
70202   return jresult;
70203 }
70204
70205
70206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
70207   int jresult ;
70208   int result;
70209
70210   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
70211   jresult = (int)result;
70212   return jresult;
70213 }
70214
70215
70216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
70217   int jresult ;
70218   int result;
70219
70220   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
70221   jresult = (int)result;
70222   return jresult;
70223 }
70224
70225
70226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
70227   void * jresult ;
70228   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
70229
70230   {
70231     try {
70232       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
70233     } catch (std::out_of_range& e) {
70234       {
70235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70236       };
70237     } catch (std::exception& e) {
70238       {
70239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70240       };
70241     } catch (Dali::DaliException e) {
70242       {
70243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70244       };
70245     } catch (...) {
70246       {
70247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70248       };
70249     }
70250   }
70251
70252   jresult = (void *)result;
70253   return jresult;
70254 }
70255
70256
70257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
70258   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
70259
70260   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
70261   {
70262     try {
70263       delete arg1;
70264     } catch (std::out_of_range& e) {
70265       {
70266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70267       };
70268     } catch (std::exception& e) {
70269       {
70270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70271       };
70272     } catch (Dali::DaliException e) {
70273       {
70274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70275       };
70276     } catch (...) {
70277       {
70278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70279       };
70280     }
70281   }
70282
70283 }
70284
70285
70286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
70287   void * jresult ;
70288   Dali::Toolkit::FlexContainer *result = 0 ;
70289
70290   {
70291     try {
70292       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
70293     } catch (std::out_of_range& e) {
70294       {
70295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70296       };
70297     } catch (std::exception& e) {
70298       {
70299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70300       };
70301     } catch (Dali::DaliException e) {
70302       {
70303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70304       };
70305     } catch (...) {
70306       {
70307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70308       };
70309     }
70310   }
70311
70312   jresult = (void *)result;
70313   return jresult;
70314 }
70315
70316
70317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
70318   void * jresult ;
70319   Dali::Toolkit::FlexContainer *arg1 = 0 ;
70320   Dali::Toolkit::FlexContainer *result = 0 ;
70321
70322   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70323   if (!arg1) {
70324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70325     return 0;
70326   }
70327   {
70328     try {
70329       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
70330     } catch (std::out_of_range& e) {
70331       {
70332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70333       };
70334     } catch (std::exception& e) {
70335       {
70336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70337       };
70338     } catch (Dali::DaliException e) {
70339       {
70340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70341       };
70342     } catch (...) {
70343       {
70344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70345       };
70346     }
70347   }
70348
70349   jresult = (void *)result;
70350   return jresult;
70351 }
70352
70353
70354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
70355   void * jresult ;
70356   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70357   Dali::Toolkit::FlexContainer *arg2 = 0 ;
70358   Dali::Toolkit::FlexContainer *result = 0 ;
70359
70360   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70361   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
70362   if (!arg2) {
70363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70364     return 0;
70365   }
70366   {
70367     try {
70368       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
70369     } catch (std::out_of_range& e) {
70370       {
70371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70372       };
70373     } catch (std::exception& e) {
70374       {
70375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70376       };
70377     } catch (Dali::DaliException e) {
70378       {
70379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70380       };
70381     } catch (...) {
70382       {
70383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70384       };
70385     }
70386   }
70387
70388   jresult = (void *)result;
70389   return jresult;
70390 }
70391
70392
70393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
70394   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70395
70396   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70397   {
70398     try {
70399       delete arg1;
70400     } catch (std::out_of_range& e) {
70401       {
70402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70403       };
70404     } catch (std::exception& e) {
70405       {
70406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70407       };
70408     } catch (Dali::DaliException e) {
70409       {
70410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70411       };
70412     } catch (...) {
70413       {
70414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70415       };
70416     }
70417   }
70418
70419 }
70420
70421
70422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
70423   void * jresult ;
70424   Dali::Toolkit::FlexContainer result;
70425
70426   {
70427     try {
70428       result = Dali::Toolkit::FlexContainer::New();
70429     } catch (std::out_of_range& e) {
70430       {
70431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70432       };
70433     } catch (std::exception& e) {
70434       {
70435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70436       };
70437     } catch (Dali::DaliException e) {
70438       {
70439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70440       };
70441     } catch (...) {
70442       {
70443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70444       };
70445     }
70446   }
70447
70448   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70449   return jresult;
70450 }
70451
70452
70453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
70454   void * jresult ;
70455   Dali::BaseHandle arg1 ;
70456   Dali::BaseHandle *argp1 ;
70457   Dali::Toolkit::FlexContainer result;
70458
70459   argp1 = (Dali::BaseHandle *)jarg1;
70460   if (!argp1) {
70461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70462     return 0;
70463   }
70464   arg1 = *argp1;
70465   {
70466     try {
70467       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
70468     } catch (std::out_of_range& e) {
70469       {
70470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70471       };
70472     } catch (std::exception& e) {
70473       {
70474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70475       };
70476     } catch (Dali::DaliException e) {
70477       {
70478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70479       };
70480     } catch (...) {
70481       {
70482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70483       };
70484     }
70485   }
70486
70487   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70488   return jresult;
70489 }
70490
70491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
70492   int jresult ;
70493   int result;
70494
70495   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
70496   jresult = (int)result;
70497   return jresult;
70498 }
70499
70500
70501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
70502   int jresult ;
70503   int result;
70504
70505   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
70506   jresult = (int)result;
70507   return jresult;
70508 }
70509
70510
70511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
70512   int jresult ;
70513   int result;
70514
70515   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
70516   jresult = (int)result;
70517   return jresult;
70518 }
70519
70520
70521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
70522   void * jresult ;
70523   Dali::Toolkit::ImageView::Property *result = 0 ;
70524
70525   {
70526     try {
70527       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
70528     } catch (std::out_of_range& e) {
70529       {
70530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70531       };
70532     } catch (std::exception& e) {
70533       {
70534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70535       };
70536     } catch (Dali::DaliException e) {
70537       {
70538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70539       };
70540     } catch (...) {
70541       {
70542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70543       };
70544     }
70545   }
70546
70547   jresult = (void *)result;
70548   return jresult;
70549 }
70550
70551
70552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
70553   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
70554
70555   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
70556   {
70557     try {
70558       delete arg1;
70559     } catch (std::out_of_range& e) {
70560       {
70561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70562       };
70563     } catch (std::exception& e) {
70564       {
70565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70566       };
70567     } catch (Dali::DaliException e) {
70568       {
70569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70570       };
70571     } catch (...) {
70572       {
70573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70574       };
70575     }
70576   }
70577
70578 }
70579
70580
70581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
70582   void * jresult ;
70583   Dali::Toolkit::ImageView *result = 0 ;
70584
70585   {
70586     try {
70587       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
70588     } catch (std::out_of_range& e) {
70589       {
70590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70591       };
70592     } catch (std::exception& e) {
70593       {
70594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70595       };
70596     } catch (Dali::DaliException e) {
70597       {
70598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70599       };
70600     } catch (...) {
70601       {
70602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70603       };
70604     }
70605   }
70606
70607   jresult = (void *)result;
70608   return jresult;
70609 }
70610
70611
70612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
70613   void * jresult ;
70614   Dali::Toolkit::ImageView result;
70615
70616   {
70617     try {
70618       result = Dali::Toolkit::ImageView::New();
70619     } catch (std::out_of_range& e) {
70620       {
70621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70622       };
70623     } catch (std::exception& e) {
70624       {
70625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70626       };
70627     } catch (Dali::DaliException e) {
70628       {
70629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70630       };
70631     } catch (...) {
70632       {
70633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70634       };
70635     }
70636   }
70637
70638   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70639   return jresult;
70640 }
70641
70642
70643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
70644   void * jresult ;
70645   Dali::Image arg1 ;
70646   Dali::Image *argp1 ;
70647   Dali::Toolkit::ImageView result;
70648
70649   argp1 = (Dali::Image *)jarg1;
70650   if (!argp1) {
70651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70652     return 0;
70653   }
70654   arg1 = *argp1;
70655   {
70656     try {
70657       result = Dali::Toolkit::ImageView::New(arg1);
70658     } catch (std::out_of_range& e) {
70659       {
70660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70661       };
70662     } catch (std::exception& e) {
70663       {
70664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70665       };
70666     } catch (Dali::DaliException e) {
70667       {
70668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70669       };
70670     } catch (...) {
70671       {
70672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70673       };
70674     }
70675   }
70676
70677   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70678   return jresult;
70679 }
70680
70681
70682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
70683   void * jresult ;
70684   std::string *arg1 = 0 ;
70685   Dali::Toolkit::ImageView result;
70686
70687   if (!jarg1) {
70688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70689     return 0;
70690   }
70691   std::string arg1_str(jarg1);
70692   arg1 = &arg1_str;
70693   {
70694     try {
70695       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
70696     } catch (std::out_of_range& e) {
70697       {
70698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70699       };
70700     } catch (std::exception& e) {
70701       {
70702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70703       };
70704     } catch (Dali::DaliException e) {
70705       {
70706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70707       };
70708     } catch (...) {
70709       {
70710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70711       };
70712     }
70713   }
70714
70715   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70716
70717   //argout typemap for const std::string&
70718
70719   return jresult;
70720 }
70721
70722
70723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
70724   void * jresult ;
70725   std::string *arg1 = 0 ;
70726   Dali::ImageDimensions arg2 ;
70727   Dali::ImageDimensions *argp2 ;
70728   Dali::Toolkit::ImageView result;
70729
70730   if (!jarg1) {
70731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70732     return 0;
70733   }
70734   std::string arg1_str(jarg1);
70735   arg1 = &arg1_str;
70736   argp2 = (Dali::ImageDimensions *)jarg2;
70737   if (!argp2) {
70738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
70739     return 0;
70740   }
70741   arg2 = *argp2;
70742   {
70743     try {
70744       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
70745     } catch (std::out_of_range& e) {
70746       {
70747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70748       };
70749     } catch (std::exception& e) {
70750       {
70751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70752       };
70753     } catch (Dali::DaliException e) {
70754       {
70755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70756       };
70757     } catch (...) {
70758       {
70759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70760       };
70761     }
70762   }
70763
70764   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70765
70766   //argout typemap for const std::string&
70767
70768   return jresult;
70769 }
70770
70771
70772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
70773   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70774
70775   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70776   {
70777     try {
70778       delete arg1;
70779     } catch (std::out_of_range& e) {
70780       {
70781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70782       };
70783     } catch (std::exception& e) {
70784       {
70785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70786       };
70787     } catch (Dali::DaliException e) {
70788       {
70789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70790       };
70791     } catch (...) {
70792       {
70793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70794       };
70795     }
70796   }
70797
70798 }
70799
70800
70801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
70802   void * jresult ;
70803   Dali::Toolkit::ImageView *arg1 = 0 ;
70804   Dali::Toolkit::ImageView *result = 0 ;
70805
70806   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70807   if (!arg1) {
70808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70809     return 0;
70810   }
70811   {
70812     try {
70813       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
70814     } catch (std::out_of_range& e) {
70815       {
70816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70817       };
70818     } catch (std::exception& e) {
70819       {
70820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70821       };
70822     } catch (Dali::DaliException e) {
70823       {
70824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70825       };
70826     } catch (...) {
70827       {
70828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70829       };
70830     }
70831   }
70832
70833   jresult = (void *)result;
70834   return jresult;
70835 }
70836
70837
70838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
70839   void * jresult ;
70840   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70841   Dali::Toolkit::ImageView *arg2 = 0 ;
70842   Dali::Toolkit::ImageView *result = 0 ;
70843
70844   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70845   arg2 = (Dali::Toolkit::ImageView *)jarg2;
70846   if (!arg2) {
70847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70848     return 0;
70849   }
70850   {
70851     try {
70852       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
70853     } catch (std::out_of_range& e) {
70854       {
70855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70856       };
70857     } catch (std::exception& e) {
70858       {
70859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70860       };
70861     } catch (Dali::DaliException e) {
70862       {
70863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70864       };
70865     } catch (...) {
70866       {
70867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70868       };
70869     }
70870   }
70871
70872   jresult = (void *)result;
70873   return jresult;
70874 }
70875
70876
70877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
70878   void * jresult ;
70879   Dali::BaseHandle arg1 ;
70880   Dali::BaseHandle *argp1 ;
70881   Dali::Toolkit::ImageView result;
70882
70883   argp1 = (Dali::BaseHandle *)jarg1;
70884   if (!argp1) {
70885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70886     return 0;
70887   }
70888   arg1 = *argp1;
70889   {
70890     try {
70891       result = Dali::Toolkit::ImageView::DownCast(arg1);
70892     } catch (std::out_of_range& e) {
70893       {
70894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70895       };
70896     } catch (std::exception& e) {
70897       {
70898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70899       };
70900     } catch (Dali::DaliException e) {
70901       {
70902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70903       };
70904     } catch (...) {
70905       {
70906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70907       };
70908     }
70909   }
70910
70911   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70912   return jresult;
70913 }
70914
70915
70916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
70917   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70918   Dali::Image arg2 ;
70919   Dali::Image *argp2 ;
70920
70921   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70922   argp2 = (Dali::Image *)jarg2;
70923   if (!argp2) {
70924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70925     return ;
70926   }
70927   arg2 = *argp2;
70928   {
70929     try {
70930       (arg1)->SetImage(arg2);
70931     } catch (std::out_of_range& e) {
70932       {
70933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70934       };
70935     } catch (std::exception& e) {
70936       {
70937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70938       };
70939     } catch (Dali::DaliException e) {
70940       {
70941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70942       };
70943     } catch (...) {
70944       {
70945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70946       };
70947     }
70948   }
70949
70950 }
70951
70952
70953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
70954   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70955   std::string *arg2 = 0 ;
70956
70957   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70958   if (!jarg2) {
70959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70960     return ;
70961   }
70962   std::string arg2_str(jarg2);
70963   arg2 = &arg2_str;
70964   {
70965     try {
70966       (arg1)->SetImage((std::string const &)*arg2);
70967     } catch (std::out_of_range& e) {
70968       {
70969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70970       };
70971     } catch (std::exception& e) {
70972       {
70973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70974       };
70975     } catch (Dali::DaliException e) {
70976       {
70977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70978       };
70979     } catch (...) {
70980       {
70981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70982       };
70983     }
70984   }
70985
70986
70987   //argout typemap for const std::string&
70988
70989 }
70990
70991
70992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
70993   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70994   std::string *arg2 = 0 ;
70995   Dali::ImageDimensions arg3 ;
70996   Dali::ImageDimensions *argp3 ;
70997
70998   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70999   if (!jarg2) {
71000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71001     return ;
71002   }
71003   std::string arg2_str(jarg2);
71004   arg2 = &arg2_str;
71005   argp3 = (Dali::ImageDimensions *)jarg3;
71006   if (!argp3) {
71007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71008     return ;
71009   }
71010   arg3 = *argp3;
71011   {
71012     try {
71013       (arg1)->SetImage((std::string const &)*arg2,arg3);
71014     } catch (std::out_of_range& e) {
71015       {
71016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71017       };
71018     } catch (std::exception& e) {
71019       {
71020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71021       };
71022     } catch (Dali::DaliException e) {
71023       {
71024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71025       };
71026     } catch (...) {
71027       {
71028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71029       };
71030     }
71031   }
71032
71033
71034   //argout typemap for const std::string&
71035
71036 }
71037
71038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
71039   void * jresult ;
71040   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71041   Dali::Image result;
71042
71043   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71044   {
71045     try {
71046       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
71047     } catch (std::out_of_range& e) {
71048       {
71049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71050       };
71051     } catch (std::exception& e) {
71052       {
71053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71054       };
71055     } catch (Dali::DaliException e) {
71056       {
71057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71058       };
71059     } catch (...) {
71060       {
71061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71062       };
71063     }
71064   }
71065
71066   jresult = new Dali::Image((const Dali::Image &)result);
71067   return jresult;
71068 }
71069
71070
71071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
71072   int jresult ;
71073   int result;
71074
71075   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
71076   jresult = (int)result;
71077   return jresult;
71078 }
71079
71080
71081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
71082   int jresult ;
71083   int result;
71084
71085   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
71086   jresult = (int)result;
71087   return jresult;
71088 }
71089
71090
71091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
71092   int jresult ;
71093   int result;
71094
71095   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
71096   jresult = (int)result;
71097   return jresult;
71098 }
71099
71100
71101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
71102   int jresult ;
71103   int result;
71104
71105   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
71106   jresult = (int)result;
71107   return jresult;
71108 }
71109
71110
71111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
71112   int jresult ;
71113   int result;
71114
71115   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
71116   jresult = (int)result;
71117   return jresult;
71118 }
71119
71120
71121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
71122   int jresult ;
71123   int result;
71124
71125   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
71126   jresult = (int)result;
71127   return jresult;
71128 }
71129
71130
71131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
71132   int jresult ;
71133   int result;
71134
71135   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
71136   jresult = (int)result;
71137   return jresult;
71138 }
71139
71140
71141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
71142   int jresult ;
71143   int result;
71144
71145   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
71146   jresult = (int)result;
71147   return jresult;
71148 }
71149
71150
71151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
71152   void * jresult ;
71153   Dali::Toolkit::Model3dView::Property *result = 0 ;
71154
71155   {
71156     try {
71157       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
71158     } catch (std::out_of_range& e) {
71159       {
71160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71161       };
71162     } catch (std::exception& e) {
71163       {
71164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71165       };
71166     } catch (Dali::DaliException e) {
71167       {
71168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71169       };
71170     } catch (...) {
71171       {
71172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71173       };
71174     }
71175   }
71176
71177   jresult = (void *)result;
71178   return jresult;
71179 }
71180
71181
71182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
71183   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
71184
71185   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
71186   {
71187     try {
71188       delete arg1;
71189     } catch (std::out_of_range& e) {
71190       {
71191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71192       };
71193     } catch (std::exception& e) {
71194       {
71195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71196       };
71197     } catch (Dali::DaliException e) {
71198       {
71199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71200       };
71201     } catch (...) {
71202       {
71203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71204       };
71205     }
71206   }
71207
71208 }
71209
71210
71211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
71212   void * jresult ;
71213   Dali::Toolkit::Model3dView result;
71214
71215   {
71216     try {
71217       result = Dali::Toolkit::Model3dView::New();
71218     } catch (std::out_of_range& e) {
71219       {
71220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71221       };
71222     } catch (std::exception& e) {
71223       {
71224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71225       };
71226     } catch (Dali::DaliException e) {
71227       {
71228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71229       };
71230     } catch (...) {
71231       {
71232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71233       };
71234     }
71235   }
71236
71237   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71238   return jresult;
71239 }
71240
71241
71242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
71243   void * jresult ;
71244   std::string *arg1 = 0 ;
71245   std::string *arg2 = 0 ;
71246   std::string *arg3 = 0 ;
71247   Dali::Toolkit::Model3dView result;
71248
71249   if (!jarg1) {
71250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71251     return 0;
71252   }
71253   std::string arg1_str(jarg1);
71254   arg1 = &arg1_str;
71255   if (!jarg2) {
71256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71257     return 0;
71258   }
71259   std::string arg2_str(jarg2);
71260   arg2 = &arg2_str;
71261   if (!jarg3) {
71262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71263     return 0;
71264   }
71265   std::string arg3_str(jarg3);
71266   arg3 = &arg3_str;
71267   {
71268     try {
71269       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
71270     } catch (std::out_of_range& e) {
71271       {
71272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71273       };
71274     } catch (std::exception& e) {
71275       {
71276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71277       };
71278     } catch (Dali::DaliException e) {
71279       {
71280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71281       };
71282     } catch (...) {
71283       {
71284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71285       };
71286     }
71287   }
71288
71289   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71290
71291   //argout typemap for const std::string&
71292
71293
71294   //argout typemap for const std::string&
71295
71296
71297   //argout typemap for const std::string&
71298
71299   return jresult;
71300 }
71301
71302
71303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
71304   void * jresult ;
71305   Dali::Toolkit::Model3dView *result = 0 ;
71306
71307   {
71308     try {
71309       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
71310     } catch (std::out_of_range& e) {
71311       {
71312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71313       };
71314     } catch (std::exception& e) {
71315       {
71316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71317       };
71318     } catch (Dali::DaliException e) {
71319       {
71320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71321       };
71322     } catch (...) {
71323       {
71324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71325       };
71326     }
71327   }
71328
71329   jresult = (void *)result;
71330   return jresult;
71331 }
71332
71333
71334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
71335   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71336
71337   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71338   {
71339     try {
71340       delete arg1;
71341     } catch (std::out_of_range& e) {
71342       {
71343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71344       };
71345     } catch (std::exception& e) {
71346       {
71347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71348       };
71349     } catch (Dali::DaliException e) {
71350       {
71351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71352       };
71353     } catch (...) {
71354       {
71355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71356       };
71357     }
71358   }
71359
71360 }
71361
71362
71363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
71364   void * jresult ;
71365   Dali::Toolkit::Model3dView *arg1 = 0 ;
71366   Dali::Toolkit::Model3dView *result = 0 ;
71367
71368   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71369   if (!arg1) {
71370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71371     return 0;
71372   }
71373   {
71374     try {
71375       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
71376     } catch (std::out_of_range& e) {
71377       {
71378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71379       };
71380     } catch (std::exception& e) {
71381       {
71382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71383       };
71384     } catch (Dali::DaliException e) {
71385       {
71386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71387       };
71388     } catch (...) {
71389       {
71390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71391       };
71392     }
71393   }
71394
71395   jresult = (void *)result;
71396   return jresult;
71397 }
71398
71399
71400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
71401   void * jresult ;
71402   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71403   Dali::Toolkit::Model3dView *arg2 = 0 ;
71404   Dali::Toolkit::Model3dView *result = 0 ;
71405
71406   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71407   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
71408   if (!arg2) {
71409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71410     return 0;
71411   }
71412   {
71413     try {
71414       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
71415     } catch (std::out_of_range& e) {
71416       {
71417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71418       };
71419     } catch (std::exception& e) {
71420       {
71421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71422       };
71423     } catch (Dali::DaliException e) {
71424       {
71425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71426       };
71427     } catch (...) {
71428       {
71429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71430       };
71431     }
71432   }
71433
71434   jresult = (void *)result;
71435   return jresult;
71436 }
71437
71438
71439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
71440   void * jresult ;
71441   Dali::BaseHandle arg1 ;
71442   Dali::BaseHandle *argp1 ;
71443   Dali::Toolkit::Model3dView result;
71444
71445   argp1 = (Dali::BaseHandle *)jarg1;
71446   if (!argp1) {
71447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71448     return 0;
71449   }
71450   arg1 = *argp1;
71451   {
71452     try {
71453       result = Dali::Toolkit::Model3dView::DownCast(arg1);
71454     } catch (std::out_of_range& e) {
71455       {
71456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71457       };
71458     } catch (std::exception& e) {
71459       {
71460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71461       };
71462     } catch (Dali::DaliException e) {
71463       {
71464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71465       };
71466     } catch (...) {
71467       {
71468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71469       };
71470     }
71471   }
71472
71473   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71474   return jresult;
71475 }
71476
71477
71478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
71479   int jresult ;
71480   int result;
71481
71482   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
71483   jresult = (int)result;
71484   return jresult;
71485 }
71486
71487
71488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
71489   int jresult ;
71490   int result;
71491
71492   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
71493   jresult = (int)result;
71494   return jresult;
71495 }
71496
71497
71498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
71499   int jresult ;
71500   int result;
71501
71502   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
71503   jresult = (int)result;
71504   return jresult;
71505 }
71506
71507
71508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
71509   int jresult ;
71510   int result;
71511
71512   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
71513   jresult = (int)result;
71514   return jresult;
71515 }
71516
71517
71518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
71519   int jresult ;
71520   int result;
71521
71522   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
71523   jresult = (int)result;
71524   return jresult;
71525 }
71526
71527
71528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
71529   int jresult ;
71530   int result;
71531
71532   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
71533   jresult = (int)result;
71534   return jresult;
71535 }
71536
71537
71538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
71539   int jresult ;
71540   int result;
71541
71542   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
71543   jresult = (int)result;
71544   return jresult;
71545 }
71546
71547
71548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
71549   int jresult ;
71550   int result;
71551
71552   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
71553   jresult = (int)result;
71554   return jresult;
71555 }
71556
71557
71558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
71559   int jresult ;
71560   int result;
71561
71562   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
71563   jresult = (int)result;
71564   return jresult;
71565 }
71566
71567
71568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
71569   void * jresult ;
71570   Dali::Toolkit::ScrollBar::Property *result = 0 ;
71571
71572   {
71573     try {
71574       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
71575     } catch (std::out_of_range& e) {
71576       {
71577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71578       };
71579     } catch (std::exception& e) {
71580       {
71581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71582       };
71583     } catch (Dali::DaliException e) {
71584       {
71585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71586       };
71587     } catch (...) {
71588       {
71589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71590       };
71591     }
71592   }
71593
71594   jresult = (void *)result;
71595   return jresult;
71596 }
71597
71598
71599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
71600   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
71601
71602   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
71603   {
71604     try {
71605       delete arg1;
71606     } catch (std::out_of_range& e) {
71607       {
71608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71609       };
71610     } catch (std::exception& e) {
71611       {
71612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71613       };
71614     } catch (Dali::DaliException e) {
71615       {
71616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71617       };
71618     } catch (...) {
71619       {
71620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71621       };
71622     }
71623   }
71624
71625 }
71626
71627
71628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
71629   void * jresult ;
71630   Dali::Toolkit::ScrollBar *result = 0 ;
71631
71632   {
71633     try {
71634       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
71635     } catch (std::out_of_range& e) {
71636       {
71637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71638       };
71639     } catch (std::exception& e) {
71640       {
71641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71642       };
71643     } catch (Dali::DaliException e) {
71644       {
71645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71646       };
71647     } catch (...) {
71648       {
71649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71650       };
71651     }
71652   }
71653
71654   jresult = (void *)result;
71655   return jresult;
71656 }
71657
71658
71659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
71660   void * jresult ;
71661   Dali::Toolkit::ScrollBar *arg1 = 0 ;
71662   Dali::Toolkit::ScrollBar *result = 0 ;
71663
71664   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71665   if (!arg1) {
71666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71667     return 0;
71668   }
71669   {
71670     try {
71671       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
71672     } catch (std::out_of_range& e) {
71673       {
71674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71675       };
71676     } catch (std::exception& e) {
71677       {
71678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71679       };
71680     } catch (Dali::DaliException e) {
71681       {
71682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71683       };
71684     } catch (...) {
71685       {
71686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71687       };
71688     }
71689   }
71690
71691   jresult = (void *)result;
71692   return jresult;
71693 }
71694
71695
71696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
71697   void * jresult ;
71698   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71699   Dali::Toolkit::ScrollBar *arg2 = 0 ;
71700   Dali::Toolkit::ScrollBar *result = 0 ;
71701
71702   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71703   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
71704   if (!arg2) {
71705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71706     return 0;
71707   }
71708   {
71709     try {
71710       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
71711     } catch (std::out_of_range& e) {
71712       {
71713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71714       };
71715     } catch (std::exception& e) {
71716       {
71717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71718       };
71719     } catch (Dali::DaliException e) {
71720       {
71721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71722       };
71723     } catch (...) {
71724       {
71725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71726       };
71727     }
71728   }
71729
71730   jresult = (void *)result;
71731   return jresult;
71732 }
71733
71734
71735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
71736   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71737
71738   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71739   {
71740     try {
71741       delete arg1;
71742     } catch (std::out_of_range& e) {
71743       {
71744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71745       };
71746     } catch (std::exception& e) {
71747       {
71748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71749       };
71750     } catch (Dali::DaliException e) {
71751       {
71752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71753       };
71754     } catch (...) {
71755       {
71756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71757       };
71758     }
71759   }
71760
71761 }
71762
71763
71764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
71765   void * jresult ;
71766   Dali::Toolkit::ScrollBar::Direction arg1 ;
71767   Dali::Toolkit::ScrollBar result;
71768
71769   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
71770   {
71771     try {
71772       result = Dali::Toolkit::ScrollBar::New(arg1);
71773     } catch (std::out_of_range& e) {
71774       {
71775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71776       };
71777     } catch (std::exception& e) {
71778       {
71779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71780       };
71781     } catch (Dali::DaliException e) {
71782       {
71783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71784       };
71785     } catch (...) {
71786       {
71787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71788       };
71789     }
71790   }
71791
71792   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71793   return jresult;
71794 }
71795
71796
71797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
71798   void * jresult ;
71799   Dali::Toolkit::ScrollBar result;
71800
71801   {
71802     try {
71803       result = Dali::Toolkit::ScrollBar::New();
71804     } catch (std::out_of_range& e) {
71805       {
71806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71807       };
71808     } catch (std::exception& e) {
71809       {
71810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71811       };
71812     } catch (Dali::DaliException e) {
71813       {
71814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71815       };
71816     } catch (...) {
71817       {
71818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71819       };
71820     }
71821   }
71822
71823   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71824   return jresult;
71825 }
71826
71827
71828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
71829   void * jresult ;
71830   Dali::BaseHandle arg1 ;
71831   Dali::BaseHandle *argp1 ;
71832   Dali::Toolkit::ScrollBar result;
71833
71834   argp1 = (Dali::BaseHandle *)jarg1;
71835   if (!argp1) {
71836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71837     return 0;
71838   }
71839   arg1 = *argp1;
71840   {
71841     try {
71842       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
71843     } catch (std::out_of_range& e) {
71844       {
71845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71846       };
71847     } catch (std::exception& e) {
71848       {
71849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71850       };
71851     } catch (Dali::DaliException e) {
71852       {
71853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71854       };
71855     } catch (...) {
71856       {
71857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71858       };
71859     }
71860   }
71861
71862   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71863   return jresult;
71864 }
71865
71866
71867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
71868   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71869   Dali::Handle arg2 ;
71870   Dali::Property::Index arg3 ;
71871   Dali::Property::Index arg4 ;
71872   Dali::Property::Index arg5 ;
71873   Dali::Property::Index arg6 ;
71874   Dali::Handle *argp2 ;
71875
71876   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71877   argp2 = (Dali::Handle *)jarg2;
71878   if (!argp2) {
71879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
71880     return ;
71881   }
71882   arg2 = *argp2;
71883   arg3 = (Dali::Property::Index)jarg3;
71884   arg4 = (Dali::Property::Index)jarg4;
71885   arg5 = (Dali::Property::Index)jarg5;
71886   arg6 = (Dali::Property::Index)jarg6;
71887   {
71888     try {
71889       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
71890     } catch (std::out_of_range& e) {
71891       {
71892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71893       };
71894     } catch (std::exception& e) {
71895       {
71896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71897       };
71898     } catch (Dali::DaliException e) {
71899       {
71900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71901       };
71902     } catch (...) {
71903       {
71904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71905       };
71906     }
71907   }
71908
71909 }
71910
71911
71912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
71913   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71914   Dali::Actor arg2 ;
71915   Dali::Actor *argp2 ;
71916
71917   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71918   argp2 = (Dali::Actor *)jarg2;
71919   if (!argp2) {
71920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71921     return ;
71922   }
71923   arg2 = *argp2;
71924   {
71925     try {
71926       (arg1)->SetScrollIndicator(arg2);
71927     } catch (std::out_of_range& e) {
71928       {
71929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71930       };
71931     } catch (std::exception& e) {
71932       {
71933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71934       };
71935     } catch (Dali::DaliException e) {
71936       {
71937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71938       };
71939     } catch (...) {
71940       {
71941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71942       };
71943     }
71944   }
71945
71946 }
71947
71948
71949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
71950   void * jresult ;
71951   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71952   Dali::Actor result;
71953
71954   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71955   {
71956     try {
71957       result = (arg1)->GetScrollIndicator();
71958     } catch (std::out_of_range& e) {
71959       {
71960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71961       };
71962     } catch (std::exception& e) {
71963       {
71964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71965       };
71966     } catch (Dali::DaliException e) {
71967       {
71968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71969       };
71970     } catch (...) {
71971       {
71972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71973       };
71974     }
71975   }
71976
71977   jresult = new Dali::Actor((const Dali::Actor &)result);
71978   return jresult;
71979 }
71980
71981
71982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
71983   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71984   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
71985
71986   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71987   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
71988   if (!arg2) {
71989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
71990     return ;
71991   }
71992   {
71993     try {
71994       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
71995     } catch (std::out_of_range& e) {
71996       {
71997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71998       };
71999     } catch (std::exception& e) {
72000       {
72001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72002       };
72003     } catch (Dali::DaliException e) {
72004       {
72005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72006       };
72007     } catch (...) {
72008       {
72009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72010       };
72011     }
72012   }
72013
72014 }
72015
72016
72017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
72018   void * jresult ;
72019   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72020
72021   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72022   {
72023     try {
72024       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()));
72025     } catch (std::out_of_range& e) {
72026       {
72027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72028       };
72029     } catch (std::exception& e) {
72030       {
72031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72032       };
72033     } catch (...) {
72034       {
72035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72036       };
72037     }
72038   }
72039   return jresult;
72040 }
72041
72042
72043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
72044   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72045   Dali::Toolkit::ScrollBar::Direction arg2 ;
72046
72047   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72048   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
72049   {
72050     try {
72051       (arg1)->SetScrollDirection(arg2);
72052     } catch (std::out_of_range& e) {
72053       {
72054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72055       };
72056     } catch (std::exception& e) {
72057       {
72058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72059       };
72060     } catch (Dali::DaliException e) {
72061       {
72062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72063       };
72064     } catch (...) {
72065       {
72066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72067       };
72068     }
72069   }
72070
72071 }
72072
72073
72074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
72075   int jresult ;
72076   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72077   Dali::Toolkit::ScrollBar::Direction result;
72078
72079   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72080   {
72081     try {
72082       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
72083     } catch (std::out_of_range& e) {
72084       {
72085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72086       };
72087     } catch (std::exception& e) {
72088       {
72089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72090       };
72091     } catch (Dali::DaliException e) {
72092       {
72093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72094       };
72095     } catch (...) {
72096       {
72097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72098       };
72099     }
72100   }
72101
72102   jresult = (int)result;
72103   return jresult;
72104 }
72105
72106
72107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
72108   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72109   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
72110
72111   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72112   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
72113   {
72114     try {
72115       (arg1)->SetIndicatorHeightPolicy(arg2);
72116     } catch (std::out_of_range& e) {
72117       {
72118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72119       };
72120     } catch (std::exception& e) {
72121       {
72122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72123       };
72124     } catch (Dali::DaliException e) {
72125       {
72126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72127       };
72128     } catch (...) {
72129       {
72130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72131       };
72132     }
72133   }
72134
72135 }
72136
72137
72138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
72139   int jresult ;
72140   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72141   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
72142
72143   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72144   {
72145     try {
72146       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
72147     } catch (std::out_of_range& e) {
72148       {
72149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72150       };
72151     } catch (std::exception& e) {
72152       {
72153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72154       };
72155     } catch (Dali::DaliException e) {
72156       {
72157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72158       };
72159     } catch (...) {
72160       {
72161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72162       };
72163     }
72164   }
72165
72166   jresult = (int)result;
72167   return jresult;
72168 }
72169
72170
72171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
72172   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72173   float arg2 ;
72174
72175   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72176   arg2 = (float)jarg2;
72177   {
72178     try {
72179       (arg1)->SetIndicatorFixedHeight(arg2);
72180     } catch (std::out_of_range& e) {
72181       {
72182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72183       };
72184     } catch (std::exception& e) {
72185       {
72186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72187       };
72188     } catch (Dali::DaliException e) {
72189       {
72190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72191       };
72192     } catch (...) {
72193       {
72194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72195       };
72196     }
72197   }
72198
72199 }
72200
72201
72202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
72203   float jresult ;
72204   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72205   float result;
72206
72207   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72208   {
72209     try {
72210       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
72211     } catch (std::out_of_range& e) {
72212       {
72213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72214       };
72215     } catch (std::exception& e) {
72216       {
72217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72218       };
72219     } catch (Dali::DaliException e) {
72220       {
72221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72222       };
72223     } catch (...) {
72224       {
72225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72226       };
72227     }
72228   }
72229
72230   jresult = result;
72231   return jresult;
72232 }
72233
72234
72235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
72236   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72237   float arg2 ;
72238
72239   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72240   arg2 = (float)jarg2;
72241   {
72242     try {
72243       (arg1)->SetIndicatorShowDuration(arg2);
72244     } catch (std::out_of_range& e) {
72245       {
72246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72247       };
72248     } catch (std::exception& e) {
72249       {
72250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72251       };
72252     } catch (Dali::DaliException e) {
72253       {
72254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72255       };
72256     } catch (...) {
72257       {
72258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72259       };
72260     }
72261   }
72262
72263 }
72264
72265
72266 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
72267   float jresult ;
72268   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72269   float result;
72270
72271   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72272   {
72273     try {
72274       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
72275     } catch (std::out_of_range& e) {
72276       {
72277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72278       };
72279     } catch (std::exception& e) {
72280       {
72281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72282       };
72283     } catch (Dali::DaliException e) {
72284       {
72285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72286       };
72287     } catch (...) {
72288       {
72289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72290       };
72291     }
72292   }
72293
72294   jresult = result;
72295   return jresult;
72296 }
72297
72298
72299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
72300   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72301   float arg2 ;
72302
72303   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72304   arg2 = (float)jarg2;
72305   {
72306     try {
72307       (arg1)->SetIndicatorHideDuration(arg2);
72308     } catch (std::out_of_range& e) {
72309       {
72310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72311       };
72312     } catch (std::exception& e) {
72313       {
72314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72315       };
72316     } catch (Dali::DaliException e) {
72317       {
72318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72319       };
72320     } catch (...) {
72321       {
72322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72323       };
72324     }
72325   }
72326
72327 }
72328
72329
72330 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
72331   float jresult ;
72332   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72333   float result;
72334
72335   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72336   {
72337     try {
72338       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
72339     } catch (std::out_of_range& e) {
72340       {
72341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72342       };
72343     } catch (std::exception& e) {
72344       {
72345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72346       };
72347     } catch (Dali::DaliException e) {
72348       {
72349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72350       };
72351     } catch (...) {
72352       {
72353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72354       };
72355     }
72356   }
72357
72358   jresult = result;
72359   return jresult;
72360 }
72361
72362
72363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
72364   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72365
72366   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72367   {
72368     try {
72369       (arg1)->ShowIndicator();
72370     } catch (std::out_of_range& e) {
72371       {
72372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72373       };
72374     } catch (std::exception& e) {
72375       {
72376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72377       };
72378     } catch (Dali::DaliException e) {
72379       {
72380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72381       };
72382     } catch (...) {
72383       {
72384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72385       };
72386     }
72387   }
72388
72389 }
72390
72391
72392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
72393   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72394
72395   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72396   {
72397     try {
72398       (arg1)->HideIndicator();
72399     } catch (std::out_of_range& e) {
72400       {
72401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72402       };
72403     } catch (std::exception& e) {
72404       {
72405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72406       };
72407     } catch (Dali::DaliException e) {
72408       {
72409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72410       };
72411     } catch (...) {
72412       {
72413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72414       };
72415     }
72416   }
72417
72418 }
72419
72420
72421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
72422   void * jresult ;
72423   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72424   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
72425
72426   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72427   {
72428     try {
72429       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
72430     } catch (std::out_of_range& e) {
72431       {
72432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72433       };
72434     } catch (std::exception& e) {
72435       {
72436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72437       };
72438     } catch (Dali::DaliException e) {
72439       {
72440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72441       };
72442     } catch (...) {
72443       {
72444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72445       };
72446     }
72447   }
72448
72449   jresult = (void *)result;
72450   return jresult;
72451 }
72452
72453
72454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
72455   void * jresult ;
72456   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72457   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
72458
72459   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72460   {
72461     try {
72462       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
72463     } catch (std::out_of_range& e) {
72464       {
72465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72466       };
72467     } catch (std::exception& e) {
72468       {
72469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72470       };
72471     } catch (Dali::DaliException e) {
72472       {
72473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72474       };
72475     } catch (...) {
72476       {
72477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72478       };
72479     }
72480   }
72481
72482   jresult = (void *)result;
72483   return jresult;
72484 }
72485
72486
72487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
72488   int jresult ;
72489   int result;
72490
72491   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
72492   jresult = (int)result;
72493   return jresult;
72494 }
72495
72496
72497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
72498   int jresult ;
72499   int result;
72500
72501   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
72502   jresult = (int)result;
72503   return jresult;
72504 }
72505
72506
72507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
72508   int jresult ;
72509   int result;
72510
72511   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
72512   jresult = (int)result;
72513   return jresult;
72514 }
72515
72516
72517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
72518   int jresult ;
72519   int result;
72520
72521   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
72522   jresult = (int)result;
72523   return jresult;
72524 }
72525
72526
72527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
72528   int jresult ;
72529   int result;
72530
72531   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
72532   jresult = (int)result;
72533   return jresult;
72534 }
72535
72536
72537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
72538   int jresult ;
72539   int result;
72540
72541   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
72542   jresult = (int)result;
72543   return jresult;
72544 }
72545
72546
72547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
72548   int jresult ;
72549   int result;
72550
72551   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
72552   jresult = (int)result;
72553   return jresult;
72554 }
72555
72556
72557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
72558   int jresult ;
72559   int result;
72560
72561   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
72562   jresult = (int)result;
72563   return jresult;
72564 }
72565
72566
72567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
72568   int jresult ;
72569   int result;
72570
72571   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
72572   jresult = (int)result;
72573   return jresult;
72574 }
72575
72576
72577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
72578   int jresult ;
72579   int result;
72580
72581   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
72582   jresult = (int)result;
72583   return jresult;
72584 }
72585
72586
72587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
72588   int jresult ;
72589   int result;
72590
72591   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
72592   jresult = (int)result;
72593   return jresult;
72594 }
72595
72596
72597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
72598   int jresult ;
72599   int result;
72600
72601   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
72602   jresult = (int)result;
72603   return jresult;
72604 }
72605
72606
72607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
72608   int jresult ;
72609   int result;
72610
72611   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
72612   jresult = (int)result;
72613   return jresult;
72614 }
72615
72616
72617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
72618   int jresult ;
72619   int result;
72620
72621   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
72622   jresult = (int)result;
72623   return jresult;
72624 }
72625
72626
72627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
72628   void * jresult ;
72629   Dali::Toolkit::Scrollable::Property *result = 0 ;
72630
72631   {
72632     try {
72633       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
72634     } catch (std::out_of_range& e) {
72635       {
72636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72637       };
72638     } catch (std::exception& e) {
72639       {
72640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72641       };
72642     } catch (Dali::DaliException e) {
72643       {
72644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72645       };
72646     } catch (...) {
72647       {
72648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72649       };
72650     }
72651   }
72652
72653   jresult = (void *)result;
72654   return jresult;
72655 }
72656
72657
72658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
72659   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
72660
72661   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
72662   {
72663     try {
72664       delete arg1;
72665     } catch (std::out_of_range& e) {
72666       {
72667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72668       };
72669     } catch (std::exception& e) {
72670       {
72671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72672       };
72673     } catch (Dali::DaliException e) {
72674       {
72675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72676       };
72677     } catch (...) {
72678       {
72679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72680       };
72681     }
72682   }
72683
72684 }
72685
72686
72687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
72688   void * jresult ;
72689   Dali::Toolkit::Scrollable *result = 0 ;
72690
72691   {
72692     try {
72693       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
72694     } catch (std::out_of_range& e) {
72695       {
72696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72697       };
72698     } catch (std::exception& e) {
72699       {
72700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72701       };
72702     } catch (Dali::DaliException e) {
72703       {
72704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72705       };
72706     } catch (...) {
72707       {
72708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72709       };
72710     }
72711   }
72712
72713   jresult = (void *)result;
72714   return jresult;
72715 }
72716
72717
72718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
72719   void * jresult ;
72720   Dali::Toolkit::Scrollable *arg1 = 0 ;
72721   Dali::Toolkit::Scrollable *result = 0 ;
72722
72723   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72724   if (!arg1) {
72725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72726     return 0;
72727   }
72728   {
72729     try {
72730       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
72731     } catch (std::out_of_range& e) {
72732       {
72733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72734       };
72735     } catch (std::exception& e) {
72736       {
72737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72738       };
72739     } catch (Dali::DaliException e) {
72740       {
72741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72742       };
72743     } catch (...) {
72744       {
72745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72746       };
72747     }
72748   }
72749
72750   jresult = (void *)result;
72751   return jresult;
72752 }
72753
72754
72755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
72756   void * jresult ;
72757   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72758   Dali::Toolkit::Scrollable *arg2 = 0 ;
72759   Dali::Toolkit::Scrollable *result = 0 ;
72760
72761   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72762   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
72763   if (!arg2) {
72764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72765     return 0;
72766   }
72767   {
72768     try {
72769       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
72770     } catch (std::out_of_range& e) {
72771       {
72772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72773       };
72774     } catch (std::exception& e) {
72775       {
72776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72777       };
72778     } catch (Dali::DaliException e) {
72779       {
72780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72781       };
72782     } catch (...) {
72783       {
72784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72785       };
72786     }
72787   }
72788
72789   jresult = (void *)result;
72790   return jresult;
72791 }
72792
72793
72794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
72795   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72796
72797   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72798   {
72799     try {
72800       delete arg1;
72801     } catch (std::out_of_range& e) {
72802       {
72803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72804       };
72805     } catch (std::exception& e) {
72806       {
72807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72808       };
72809     } catch (Dali::DaliException e) {
72810       {
72811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72812       };
72813     } catch (...) {
72814       {
72815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72816       };
72817     }
72818   }
72819
72820 }
72821
72822
72823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
72824   void * jresult ;
72825   Dali::BaseHandle arg1 ;
72826   Dali::BaseHandle *argp1 ;
72827   Dali::Toolkit::Scrollable result;
72828
72829   argp1 = (Dali::BaseHandle *)jarg1;
72830   if (!argp1) {
72831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72832     return 0;
72833   }
72834   arg1 = *argp1;
72835   {
72836     try {
72837       result = Dali::Toolkit::Scrollable::DownCast(arg1);
72838     } catch (std::out_of_range& e) {
72839       {
72840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72841       };
72842     } catch (std::exception& e) {
72843       {
72844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72845       };
72846     } catch (Dali::DaliException e) {
72847       {
72848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72849       };
72850     } catch (...) {
72851       {
72852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72853       };
72854     }
72855   }
72856
72857   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
72858   return jresult;
72859 }
72860
72861
72862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
72863   unsigned int jresult ;
72864   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72865   bool result;
72866
72867   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72868   {
72869     try {
72870       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
72871     } catch (std::out_of_range& e) {
72872       {
72873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72874       };
72875     } catch (std::exception& e) {
72876       {
72877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72878       };
72879     } catch (Dali::DaliException e) {
72880       {
72881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72882       };
72883     } catch (...) {
72884       {
72885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72886       };
72887     }
72888   }
72889
72890   jresult = result;
72891   return jresult;
72892 }
72893
72894
72895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
72896   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72897   bool arg2 ;
72898
72899   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72900   arg2 = jarg2 ? true : false;
72901   {
72902     try {
72903       (arg1)->SetOvershootEnabled(arg2);
72904     } catch (std::out_of_range& e) {
72905       {
72906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72907       };
72908     } catch (std::exception& e) {
72909       {
72910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72911       };
72912     } catch (Dali::DaliException e) {
72913       {
72914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72915       };
72916     } catch (...) {
72917       {
72918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72919       };
72920     }
72921   }
72922
72923 }
72924
72925
72926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
72927   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72928   Dali::Vector4 *arg2 = 0 ;
72929
72930   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72931   arg2 = (Dali::Vector4 *)jarg2;
72932   if (!arg2) {
72933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
72934     return ;
72935   }
72936   {
72937     try {
72938       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
72939     } catch (std::out_of_range& e) {
72940       {
72941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72942       };
72943     } catch (std::exception& e) {
72944       {
72945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72946       };
72947     } catch (Dali::DaliException e) {
72948       {
72949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72950       };
72951     } catch (...) {
72952       {
72953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72954       };
72955     }
72956   }
72957
72958 }
72959
72960
72961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
72962   void * jresult ;
72963   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72964   Dali::Vector4 result;
72965
72966   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72967   {
72968     try {
72969       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
72970     } catch (std::out_of_range& e) {
72971       {
72972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72973       };
72974     } catch (std::exception& e) {
72975       {
72976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72977       };
72978     } catch (Dali::DaliException e) {
72979       {
72980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72981       };
72982     } catch (...) {
72983       {
72984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72985       };
72986     }
72987   }
72988
72989   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
72990   return jresult;
72991 }
72992
72993
72994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
72995   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72996   float arg2 ;
72997
72998   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72999   arg2 = (float)jarg2;
73000   {
73001     try {
73002       (arg1)->SetOvershootAnimationSpeed(arg2);
73003     } catch (std::out_of_range& e) {
73004       {
73005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73006       };
73007     } catch (std::exception& e) {
73008       {
73009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73010       };
73011     } catch (Dali::DaliException e) {
73012       {
73013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73014       };
73015     } catch (...) {
73016       {
73017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73018       };
73019     }
73020   }
73021
73022 }
73023
73024
73025 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
73026   float jresult ;
73027   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73028   float result;
73029
73030   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73031   {
73032     try {
73033       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
73034     } catch (std::out_of_range& e) {
73035       {
73036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73037       };
73038     } catch (std::exception& e) {
73039       {
73040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73041       };
73042     } catch (Dali::DaliException e) {
73043       {
73044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73045       };
73046     } catch (...) {
73047       {
73048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73049       };
73050     }
73051   }
73052
73053   jresult = result;
73054   return jresult;
73055 }
73056
73057
73058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
73059   void * jresult ;
73060   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73061   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
73062
73063   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73064   {
73065     try {
73066       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
73067     } catch (std::out_of_range& e) {
73068       {
73069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73070       };
73071     } catch (std::exception& e) {
73072       {
73073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73074       };
73075     } catch (Dali::DaliException e) {
73076       {
73077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73078       };
73079     } catch (...) {
73080       {
73081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73082       };
73083     }
73084   }
73085
73086   jresult = (void *)result;
73087   return jresult;
73088 }
73089
73090
73091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
73092   void * jresult ;
73093   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73094   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
73095
73096   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73097   {
73098     try {
73099       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
73100     } catch (std::out_of_range& e) {
73101       {
73102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73103       };
73104     } catch (std::exception& e) {
73105       {
73106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73107       };
73108     } catch (Dali::DaliException e) {
73109       {
73110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73111       };
73112     } catch (...) {
73113       {
73114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73115       };
73116     }
73117   }
73118
73119   jresult = (void *)result;
73120   return jresult;
73121 }
73122
73123
73124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
73125   void * jresult ;
73126   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73127   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
73128
73129   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73130   {
73131     try {
73132       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
73133     } catch (std::out_of_range& e) {
73134       {
73135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73136       };
73137     } catch (std::exception& e) {
73138       {
73139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73140       };
73141     } catch (Dali::DaliException e) {
73142       {
73143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73144       };
73145     } catch (...) {
73146       {
73147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73148       };
73149     }
73150   }
73151
73152   jresult = (void *)result;
73153   return jresult;
73154 }
73155
73156
73157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
73158   unsigned int jresult ;
73159   Dali::Toolkit::ControlOrientation::Type arg1 ;
73160   bool result;
73161
73162   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
73163   {
73164     try {
73165       result = (bool)Dali::Toolkit::IsVertical(arg1);
73166     } catch (std::out_of_range& e) {
73167       {
73168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73169       };
73170     } catch (std::exception& e) {
73171       {
73172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73173       };
73174     } catch (Dali::DaliException e) {
73175       {
73176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73177       };
73178     } catch (...) {
73179       {
73180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73181       };
73182     }
73183   }
73184
73185   jresult = result;
73186   return jresult;
73187 }
73188
73189
73190 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
73191   unsigned int jresult ;
73192   Dali::Toolkit::ControlOrientation::Type arg1 ;
73193   bool result;
73194
73195   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
73196   {
73197     try {
73198       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
73199     } catch (std::out_of_range& e) {
73200       {
73201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73202       };
73203     } catch (std::exception& e) {
73204       {
73205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73206       };
73207     } catch (Dali::DaliException e) {
73208       {
73209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73210       };
73211     } catch (...) {
73212       {
73213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73214       };
73215     }
73216   }
73217
73218   jresult = result;
73219   return jresult;
73220 }
73221
73222
73223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
73224   void * jresult ;
73225   unsigned int arg1 ;
73226   unsigned int arg2 ;
73227   Dali::Toolkit::ItemRange *result = 0 ;
73228
73229   arg1 = (unsigned int)jarg1;
73230   arg2 = (unsigned int)jarg2;
73231   {
73232     try {
73233       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
73234     } catch (std::out_of_range& e) {
73235       {
73236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73237       };
73238     } catch (std::exception& e) {
73239       {
73240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73241       };
73242     } catch (Dali::DaliException e) {
73243       {
73244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73245       };
73246     } catch (...) {
73247       {
73248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73249       };
73250     }
73251   }
73252
73253   jresult = (void *)result;
73254   return jresult;
73255 }
73256
73257
73258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
73259   void * jresult ;
73260   Dali::Toolkit::ItemRange *arg1 = 0 ;
73261   Dali::Toolkit::ItemRange *result = 0 ;
73262
73263   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73264   if (!arg1) {
73265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73266     return 0;
73267   }
73268   {
73269     try {
73270       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
73271     } catch (std::out_of_range& e) {
73272       {
73273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73274       };
73275     } catch (std::exception& e) {
73276       {
73277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73278       };
73279     } catch (Dali::DaliException e) {
73280       {
73281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73282       };
73283     } catch (...) {
73284       {
73285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73286       };
73287     }
73288   }
73289
73290   jresult = (void *)result;
73291   return jresult;
73292 }
73293
73294
73295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
73296   void * jresult ;
73297   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73298   Dali::Toolkit::ItemRange *arg2 = 0 ;
73299   Dali::Toolkit::ItemRange *result = 0 ;
73300
73301   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73302   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73303   if (!arg2) {
73304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73305     return 0;
73306   }
73307   {
73308     try {
73309       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
73310     } catch (std::out_of_range& e) {
73311       {
73312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73313       };
73314     } catch (std::exception& e) {
73315       {
73316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73317       };
73318     } catch (Dali::DaliException e) {
73319       {
73320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73321       };
73322     } catch (...) {
73323       {
73324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73325       };
73326     }
73327   }
73328
73329   jresult = (void *)result;
73330   return jresult;
73331 }
73332
73333
73334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
73335   unsigned int jresult ;
73336   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73337   unsigned int arg2 ;
73338   bool result;
73339
73340   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73341   arg2 = (unsigned int)jarg2;
73342   {
73343     try {
73344       result = (bool)(arg1)->Within(arg2);
73345     } catch (std::out_of_range& e) {
73346       {
73347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73348       };
73349     } catch (std::exception& e) {
73350       {
73351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73352       };
73353     } catch (Dali::DaliException e) {
73354       {
73355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73356       };
73357     } catch (...) {
73358       {
73359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73360       };
73361     }
73362   }
73363
73364   jresult = result;
73365   return jresult;
73366 }
73367
73368
73369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
73370   void * jresult ;
73371   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73372   Dali::Toolkit::ItemRange *arg2 = 0 ;
73373   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73374
73375   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73376   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73377   if (!arg2) {
73378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73379     return 0;
73380   }
73381   {
73382     try {
73383       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
73384     } catch (std::out_of_range& e) {
73385       {
73386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73387       };
73388     } catch (std::exception& e) {
73389       {
73390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73391       };
73392     } catch (Dali::DaliException e) {
73393       {
73394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73395       };
73396     } catch (...) {
73397       {
73398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73399       };
73400     }
73401   }
73402
73403   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73404   return jresult;
73405 }
73406
73407
73408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
73409   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73410   unsigned int arg2 ;
73411
73412   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73413   arg2 = (unsigned int)jarg2;
73414   if (arg1) (arg1)->begin = arg2;
73415 }
73416
73417
73418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
73419   unsigned int jresult ;
73420   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73421   unsigned int result;
73422
73423   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73424   result = (unsigned int) ((arg1)->begin);
73425   jresult = result;
73426   return jresult;
73427 }
73428
73429
73430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
73431   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73432   unsigned int arg2 ;
73433
73434   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73435   arg2 = (unsigned int)jarg2;
73436   if (arg1) (arg1)->end = arg2;
73437 }
73438
73439
73440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
73441   unsigned int jresult ;
73442   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73443   unsigned int result;
73444
73445   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73446   result = (unsigned int) ((arg1)->end);
73447   jresult = result;
73448   return jresult;
73449 }
73450
73451
73452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
73453   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73454
73455   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73456   {
73457     try {
73458       delete arg1;
73459     } catch (std::out_of_range& e) {
73460       {
73461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73462       };
73463     } catch (std::exception& e) {
73464       {
73465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73466       };
73467     } catch (Dali::DaliException e) {
73468       {
73469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73470       };
73471     } catch (...) {
73472       {
73473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73474       };
73475     }
73476   }
73477
73478 }
73479
73480
73481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
73482   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73483
73484   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73485   {
73486     try {
73487       delete arg1;
73488     } catch (std::out_of_range& e) {
73489       {
73490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73491       };
73492     } catch (std::exception& e) {
73493       {
73494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73495       };
73496     } catch (Dali::DaliException e) {
73497       {
73498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73499       };
73500     } catch (...) {
73501       {
73502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73503       };
73504     }
73505   }
73506
73507 }
73508
73509
73510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
73511   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73512   Dali::Toolkit::ControlOrientation::Type arg2 ;
73513
73514   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73515   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
73516   {
73517     try {
73518       (arg1)->SetOrientation(arg2);
73519     } catch (std::out_of_range& e) {
73520       {
73521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73522       };
73523     } catch (std::exception& e) {
73524       {
73525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73526       };
73527     } catch (Dali::DaliException e) {
73528       {
73529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73530       };
73531     } catch (...) {
73532       {
73533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73534       };
73535     }
73536   }
73537
73538 }
73539
73540
73541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
73542   int jresult ;
73543   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73544   Dali::Toolkit::ControlOrientation::Type result;
73545
73546   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73547   {
73548     try {
73549       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
73550     } catch (std::out_of_range& e) {
73551       {
73552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73553       };
73554     } catch (std::exception& e) {
73555       {
73556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73557       };
73558     } catch (Dali::DaliException e) {
73559       {
73560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73561       };
73562     } catch (...) {
73563       {
73564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73565       };
73566     }
73567   }
73568
73569   jresult = (int)result;
73570   return jresult;
73571 }
73572
73573
73574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
73575   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73576   Dali::Property::Map *arg2 = 0 ;
73577
73578   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73579   arg2 = (Dali::Property::Map *)jarg2;
73580   if (!arg2) {
73581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
73582     return ;
73583   }
73584   {
73585     try {
73586       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
73587     } catch (std::out_of_range& e) {
73588       {
73589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73590       };
73591     } catch (std::exception& e) {
73592       {
73593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73594       };
73595     } catch (Dali::DaliException e) {
73596       {
73597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73598       };
73599     } catch (...) {
73600       {
73601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73602       };
73603     }
73604   }
73605
73606 }
73607
73608
73609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
73610   void * jresult ;
73611   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73612   Dali::Property::Map result;
73613
73614   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73615   {
73616     try {
73617       result = (arg1)->GetLayoutProperties();
73618     } catch (std::out_of_range& e) {
73619       {
73620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73621       };
73622     } catch (std::exception& e) {
73623       {
73624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73625       };
73626     } catch (Dali::DaliException e) {
73627       {
73628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73629       };
73630     } catch (...) {
73631       {
73632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73633       };
73634     }
73635   }
73636
73637   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
73638   return jresult;
73639 }
73640
73641
73642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
73643   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73644   unsigned int arg2 ;
73645   Dali::Vector3 *arg3 = 0 ;
73646   Dali::Vector3 *arg4 = 0 ;
73647
73648   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73649   arg2 = (unsigned int)jarg2;
73650   arg3 = (Dali::Vector3 *)jarg3;
73651   if (!arg3) {
73652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73653     return ;
73654   }
73655   arg4 = (Dali::Vector3 *)jarg4;
73656   if (!arg4) {
73657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
73658     return ;
73659   }
73660   {
73661     try {
73662       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
73663     } catch (std::out_of_range& e) {
73664       {
73665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73666       };
73667     } catch (std::exception& e) {
73668       {
73669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73670       };
73671     } catch (Dali::DaliException e) {
73672       {
73673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73674       };
73675     } catch (...) {
73676       {
73677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73678       };
73679     }
73680   }
73681
73682 }
73683
73684
73685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
73686   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73687   Dali::Vector3 *arg2 = 0 ;
73688
73689   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73690   arg2 = (Dali::Vector3 *)jarg2;
73691   if (!arg2) {
73692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73693     return ;
73694   }
73695   {
73696     try {
73697       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
73698     } catch (std::out_of_range& e) {
73699       {
73700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73701       };
73702     } catch (std::exception& e) {
73703       {
73704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73705       };
73706     } catch (Dali::DaliException e) {
73707       {
73708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73709       };
73710     } catch (...) {
73711       {
73712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73713       };
73714     }
73715   }
73716
73717 }
73718
73719
73720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
73721   float jresult ;
73722   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73723   unsigned int arg2 ;
73724   Dali::Vector3 arg3 ;
73725   Dali::Vector3 *argp3 ;
73726   float result;
73727
73728   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73729   arg2 = (unsigned int)jarg2;
73730   argp3 = (Dali::Vector3 *)jarg3;
73731   if (!argp3) {
73732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73733     return 0;
73734   }
73735   arg3 = *argp3;
73736   {
73737     try {
73738       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
73739     } catch (std::out_of_range& e) {
73740       {
73741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73742       };
73743     } catch (std::exception& e) {
73744       {
73745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73746       };
73747     } catch (Dali::DaliException e) {
73748       {
73749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73750       };
73751     } catch (...) {
73752       {
73753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73754       };
73755     }
73756   }
73757
73758   jresult = result;
73759   return jresult;
73760 }
73761
73762
73763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
73764   float jresult ;
73765   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73766   float arg2 ;
73767   float result;
73768
73769   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73770   arg2 = (float)jarg2;
73771   {
73772     try {
73773       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
73774     } catch (std::out_of_range& e) {
73775       {
73776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73777       };
73778     } catch (std::exception& e) {
73779       {
73780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73781       };
73782     } catch (Dali::DaliException e) {
73783       {
73784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73785       };
73786     } catch (...) {
73787       {
73788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73789       };
73790     }
73791   }
73792
73793   jresult = result;
73794   return jresult;
73795 }
73796
73797
73798 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
73799   float jresult ;
73800   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73801   unsigned int arg2 ;
73802   float result;
73803
73804   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73805   arg2 = (unsigned int)jarg2;
73806   {
73807     try {
73808       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
73809     } catch (std::out_of_range& e) {
73810       {
73811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73812       };
73813     } catch (std::exception& e) {
73814       {
73815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73816       };
73817     } catch (Dali::DaliException e) {
73818       {
73819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73820       };
73821     } catch (...) {
73822       {
73823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73824       };
73825     }
73826   }
73827
73828   jresult = result;
73829   return jresult;
73830 }
73831
73832
73833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
73834   void * jresult ;
73835   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73836   float arg2 ;
73837   Dali::Vector3 arg3 ;
73838   Dali::Vector3 *argp3 ;
73839   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73840
73841   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73842   arg2 = (float)jarg2;
73843   argp3 = (Dali::Vector3 *)jarg3;
73844   if (!argp3) {
73845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73846     return 0;
73847   }
73848   arg3 = *argp3;
73849   {
73850     try {
73851       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
73852     } catch (std::out_of_range& e) {
73853       {
73854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73855       };
73856     } catch (std::exception& e) {
73857       {
73858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73859       };
73860     } catch (Dali::DaliException e) {
73861       {
73862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73863       };
73864     } catch (...) {
73865       {
73866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73867       };
73868     }
73869   }
73870
73871   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73872   return jresult;
73873 }
73874
73875
73876 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
73877   float jresult ;
73878   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73879   int arg2 ;
73880   float arg3 ;
73881   Dali::Vector3 *arg4 = 0 ;
73882   float result;
73883
73884   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73885   arg2 = (int)jarg2;
73886   arg3 = (float)jarg3;
73887   arg4 = (Dali::Vector3 *)jarg4;
73888   if (!arg4) {
73889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73890     return 0;
73891   }
73892   {
73893     try {
73894       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
73895     } catch (std::out_of_range& e) {
73896       {
73897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73898       };
73899     } catch (std::exception& e) {
73900       {
73901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73902       };
73903     } catch (Dali::DaliException e) {
73904       {
73905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73906       };
73907     } catch (...) {
73908       {
73909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73910       };
73911     }
73912   }
73913
73914   jresult = result;
73915   return jresult;
73916 }
73917
73918
73919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
73920   unsigned int jresult ;
73921   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73922   Dali::Vector3 arg2 ;
73923   Dali::Vector3 *argp2 ;
73924   unsigned int result;
73925
73926   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73927   argp2 = (Dali::Vector3 *)jarg2;
73928   if (!argp2) {
73929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73930     return 0;
73931   }
73932   arg2 = *argp2;
73933   {
73934     try {
73935       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
73936     } catch (std::out_of_range& e) {
73937       {
73938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73939       };
73940     } catch (std::exception& e) {
73941       {
73942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73943       };
73944     } catch (Dali::DaliException e) {
73945       {
73946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73947       };
73948     } catch (...) {
73949       {
73950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73951       };
73952     }
73953   }
73954
73955   jresult = result;
73956   return jresult;
73957 }
73958
73959
73960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
73961   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73962   unsigned int arg2 ;
73963   Dali::Vector3 *arg3 = 0 ;
73964   Dali::Vector3 *arg4 = 0 ;
73965
73966   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73967   arg2 = (unsigned int)jarg2;
73968   arg3 = (Dali::Vector3 *)jarg3;
73969   if (!arg3) {
73970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73971     return ;
73972   }
73973   arg4 = (Dali::Vector3 *)jarg4;
73974   if (!arg4) {
73975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
73976     return ;
73977   }
73978   {
73979     try {
73980       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
73981     } catch (std::out_of_range& e) {
73982       {
73983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73984       };
73985     } catch (std::exception& e) {
73986       {
73987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73988       };
73989     } catch (Dali::DaliException e) {
73990       {
73991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73992       };
73993     } catch (...) {
73994       {
73995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73996       };
73997     }
73998   }
73999
74000 }
74001
74002
74003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
74004   void * jresult ;
74005   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74006   Dali::Degree result;
74007
74008   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74009   {
74010     try {
74011       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
74012     } catch (std::out_of_range& e) {
74013       {
74014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74015       };
74016     } catch (std::exception& e) {
74017       {
74018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74019       };
74020     } catch (Dali::DaliException e) {
74021       {
74022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74023       };
74024     } catch (...) {
74025       {
74026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74027       };
74028     }
74029   }
74030
74031   jresult = new Dali::Degree((const Dali::Degree &)result);
74032   return jresult;
74033 }
74034
74035
74036 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
74037   float jresult ;
74038   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74039   float result;
74040
74041   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74042   {
74043     try {
74044       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
74045     } catch (std::out_of_range& e) {
74046       {
74047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74048       };
74049     } catch (std::exception& e) {
74050       {
74051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74052       };
74053     } catch (Dali::DaliException e) {
74054       {
74055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74056       };
74057     } catch (...) {
74058       {
74059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74060       };
74061     }
74062   }
74063
74064   jresult = result;
74065   return jresult;
74066 }
74067
74068
74069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
74070   float jresult ;
74071   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74072   float result;
74073
74074   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74075   {
74076     try {
74077       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
74078     } catch (std::out_of_range& e) {
74079       {
74080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74081       };
74082     } catch (std::exception& e) {
74083       {
74084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74085       };
74086     } catch (Dali::DaliException e) {
74087       {
74088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74089       };
74090     } catch (...) {
74091       {
74092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74093       };
74094     }
74095   }
74096
74097   jresult = result;
74098   return jresult;
74099 }
74100
74101
74102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
74103   float jresult ;
74104   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74105   float result;
74106
74107   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74108   {
74109     try {
74110       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
74111     } catch (std::out_of_range& e) {
74112       {
74113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74114       };
74115     } catch (std::exception& e) {
74116       {
74117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74118       };
74119     } catch (Dali::DaliException e) {
74120       {
74121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74122       };
74123     } catch (...) {
74124       {
74125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74126       };
74127     }
74128   }
74129
74130   jresult = result;
74131   return jresult;
74132 }
74133
74134
74135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
74136   int jresult ;
74137   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74138   int arg2 ;
74139   int arg3 ;
74140   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
74141   bool arg5 ;
74142   int result;
74143
74144   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74145   arg2 = (int)jarg2;
74146   arg3 = (int)jarg3;
74147   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
74148   arg5 = jarg5 ? true : false;
74149   {
74150     try {
74151       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
74152     } catch (std::out_of_range& e) {
74153       {
74154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74155       };
74156     } catch (std::exception& e) {
74157       {
74158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74159       };
74160     } catch (Dali::DaliException e) {
74161       {
74162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74163       };
74164     } catch (...) {
74165       {
74166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74167       };
74168     }
74169   }
74170
74171   jresult = result;
74172   return jresult;
74173 }
74174
74175
74176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
74177   float jresult ;
74178   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74179   float result;
74180
74181   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74182   {
74183     try {
74184       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
74185     } catch (std::out_of_range& e) {
74186       {
74187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74188       };
74189     } catch (std::exception& e) {
74190       {
74191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74192       };
74193     } catch (Dali::DaliException e) {
74194       {
74195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74196       };
74197     } catch (...) {
74198       {
74199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74200       };
74201     }
74202   }
74203
74204   jresult = result;
74205   return jresult;
74206 }
74207
74208
74209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
74210   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74211   Dali::Actor *arg2 = 0 ;
74212   int arg3 ;
74213   Dali::Vector3 *arg4 = 0 ;
74214   Dali::Actor *arg5 = 0 ;
74215
74216   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74217   arg2 = (Dali::Actor *)jarg2;
74218   if (!arg2) {
74219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74220     return ;
74221   }
74222   arg3 = (int)jarg3;
74223   arg4 = (Dali::Vector3 *)jarg4;
74224   if (!arg4) {
74225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74226     return ;
74227   }
74228   arg5 = (Dali::Actor *)jarg5;
74229   if (!arg5) {
74230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
74231     return ;
74232   }
74233   {
74234     try {
74235       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
74236     } catch (std::out_of_range& e) {
74237       {
74238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74239       };
74240     } catch (std::exception& e) {
74241       {
74242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74243       };
74244     } catch (Dali::DaliException e) {
74245       {
74246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74247       };
74248     } catch (...) {
74249       {
74250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74251       };
74252     }
74253   }
74254
74255 }
74256
74257
74258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
74259   void * jresult ;
74260   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74261   int arg2 ;
74262   float arg3 ;
74263   Dali::Vector3 *arg4 = 0 ;
74264   Dali::Vector3 result;
74265
74266   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74267   arg2 = (int)jarg2;
74268   arg3 = (float)jarg3;
74269   arg4 = (Dali::Vector3 *)jarg4;
74270   if (!arg4) {
74271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74272     return 0;
74273   }
74274   {
74275     try {
74276       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
74277     } catch (std::out_of_range& e) {
74278       {
74279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74280       };
74281     } catch (std::exception& e) {
74282       {
74283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74284       };
74285     } catch (Dali::DaliException e) {
74286       {
74287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74288       };
74289     } catch (...) {
74290       {
74291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74292       };
74293     }
74294   }
74295
74296   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
74297   return jresult;
74298 }
74299
74300
74301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
74302   void * jresult ;
74303   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
74304   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
74305
74306   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
74307   {
74308     try {
74309       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
74310     } catch (std::out_of_range& e) {
74311       {
74312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74313       };
74314     } catch (std::exception& e) {
74315       {
74316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74317       };
74318     } catch (Dali::DaliException e) {
74319       {
74320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74321       };
74322     } catch (...) {
74323       {
74324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74325       };
74326     }
74327   }
74328
74329   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
74330   return jresult;
74331 }
74332
74333
74334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
74335   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74336
74337   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74338   {
74339     try {
74340       delete arg1;
74341     } catch (std::out_of_range& e) {
74342       {
74343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74344       };
74345     } catch (std::exception& e) {
74346       {
74347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74348       };
74349     } catch (Dali::DaliException e) {
74350       {
74351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74352       };
74353     } catch (...) {
74354       {
74355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74356       };
74357     }
74358   }
74359
74360 }
74361
74362
74363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
74364   unsigned int jresult ;
74365   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74366   unsigned int result;
74367
74368   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74369   {
74370     try {
74371       result = (unsigned int)(arg1)->GetNumberOfItems();
74372     } catch (std::out_of_range& e) {
74373       {
74374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74375       };
74376     } catch (std::exception& e) {
74377       {
74378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74379       };
74380     } catch (Dali::DaliException e) {
74381       {
74382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74383       };
74384     } catch (...) {
74385       {
74386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74387       };
74388     }
74389   }
74390
74391   jresult = result;
74392   return jresult;
74393 }
74394
74395
74396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
74397   void * jresult ;
74398   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74399   unsigned int arg2 ;
74400   Dali::Actor result;
74401
74402   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74403   arg2 = (unsigned int)jarg2;
74404   {
74405     try {
74406       result = (arg1)->NewItem(arg2);
74407     } catch (std::out_of_range& e) {
74408       {
74409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74410       };
74411     } catch (std::exception& e) {
74412       {
74413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74414       };
74415     } catch (Dali::DaliException e) {
74416       {
74417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74418       };
74419     } catch (...) {
74420       {
74421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74422       };
74423     }
74424   }
74425
74426   jresult = new Dali::Actor((const Dali::Actor &)result);
74427   return jresult;
74428 }
74429
74430
74431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
74432   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74433   unsigned int arg2 ;
74434   Dali::Actor arg3 ;
74435   Dali::Actor *argp3 ;
74436
74437   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74438   arg2 = (unsigned int)jarg2;
74439   argp3 = (Dali::Actor *)jarg3;
74440   if (!argp3) {
74441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74442     return ;
74443   }
74444   arg3 = *argp3;
74445   {
74446     try {
74447       (arg1)->ItemReleased(arg2,arg3);
74448     } catch (std::out_of_range& e) {
74449       {
74450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74451       };
74452     } catch (std::exception& e) {
74453       {
74454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74455       };
74456     } catch (Dali::DaliException e) {
74457       {
74458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74459       };
74460     } catch (...) {
74461       {
74462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74463       };
74464     }
74465   }
74466
74467 }
74468
74469
74470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
74471   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74472   unsigned int arg2 ;
74473   Dali::Actor arg3 ;
74474   Dali::Actor *argp3 ;
74475
74476   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74477   arg2 = (unsigned int)jarg2;
74478   argp3 = (Dali::Actor *)jarg3;
74479   if (!argp3) {
74480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74481     return ;
74482   }
74483   arg3 = *argp3;
74484   {
74485     try {
74486       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
74487     } catch (std::out_of_range& e) {
74488       {
74489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74490       };
74491     } catch (std::exception& e) {
74492       {
74493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74494       };
74495     } catch (Dali::DaliException e) {
74496       {
74497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74498       };
74499     } catch (...) {
74500       {
74501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74502       };
74503     }
74504   }
74505
74506 }
74507
74508
74509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
74510   void * jresult ;
74511   Dali::Toolkit::ItemFactory *result = 0 ;
74512
74513   {
74514     try {
74515       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
74516     } catch (std::out_of_range& e) {
74517       {
74518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74519       };
74520     } catch (std::exception& e) {
74521       {
74522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74523       };
74524     } catch (Dali::DaliException e) {
74525       {
74526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74527       };
74528     } catch (...) {
74529       {
74530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74531       };
74532     }
74533   }
74534
74535   jresult = (void *)result;
74536   return jresult;
74537 }
74538
74539
74540 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) {
74541   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
74542   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
74543   if (director) {
74544     director->swig_connect_director(callback0, callback1, callback2);
74545   }
74546 }
74547
74548
74549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
74550   int jresult ;
74551   int result;
74552
74553   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
74554   jresult = (int)result;
74555   return jresult;
74556 }
74557
74558
74559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
74560   int jresult ;
74561   int result;
74562
74563   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
74564   jresult = (int)result;
74565   return jresult;
74566 }
74567
74568
74569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74570   int jresult ;
74571   int result;
74572
74573   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74574   jresult = (int)result;
74575   return jresult;
74576 }
74577
74578
74579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
74580   int jresult ;
74581   int result;
74582
74583   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
74584   jresult = (int)result;
74585   return jresult;
74586 }
74587
74588
74589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
74590   int jresult ;
74591   int result;
74592
74593   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
74594   jresult = (int)result;
74595   return jresult;
74596 }
74597
74598
74599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
74600   int jresult ;
74601   int result;
74602
74603   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
74604   jresult = (int)result;
74605   return jresult;
74606 }
74607
74608
74609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
74610   int jresult ;
74611   int result;
74612
74613   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
74614   jresult = (int)result;
74615   return jresult;
74616 }
74617
74618
74619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
74620   int jresult ;
74621   int result;
74622
74623   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
74624   jresult = (int)result;
74625   return jresult;
74626 }
74627
74628
74629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
74630   int jresult ;
74631   int result;
74632
74633   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
74634   jresult = (int)result;
74635   return jresult;
74636 }
74637
74638
74639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
74640   int jresult ;
74641   int result;
74642
74643   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
74644   jresult = (int)result;
74645   return jresult;
74646 }
74647
74648
74649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
74650   int jresult ;
74651   int result;
74652
74653   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
74654   jresult = (int)result;
74655   return jresult;
74656 }
74657
74658
74659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
74660   void * jresult ;
74661   Dali::Toolkit::ItemView::Property *result = 0 ;
74662
74663   {
74664     try {
74665       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
74666     } catch (std::out_of_range& e) {
74667       {
74668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74669       };
74670     } catch (std::exception& e) {
74671       {
74672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74673       };
74674     } catch (Dali::DaliException e) {
74675       {
74676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74677       };
74678     } catch (...) {
74679       {
74680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74681       };
74682     }
74683   }
74684
74685   jresult = (void *)result;
74686   return jresult;
74687 }
74688
74689
74690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
74691   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
74692
74693   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
74694   {
74695     try {
74696       delete arg1;
74697     } catch (std::out_of_range& e) {
74698       {
74699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74700       };
74701     } catch (std::exception& e) {
74702       {
74703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74704       };
74705     } catch (Dali::DaliException e) {
74706       {
74707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74708       };
74709     } catch (...) {
74710       {
74711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74712       };
74713     }
74714   }
74715
74716 }
74717
74718
74719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
74720   void * jresult ;
74721   Dali::Toolkit::ItemView *result = 0 ;
74722
74723   {
74724     try {
74725       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
74726     } catch (std::out_of_range& e) {
74727       {
74728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74729       };
74730     } catch (std::exception& e) {
74731       {
74732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74733       };
74734     } catch (Dali::DaliException e) {
74735       {
74736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74737       };
74738     } catch (...) {
74739       {
74740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74741       };
74742     }
74743   }
74744
74745   jresult = (void *)result;
74746   return jresult;
74747 }
74748
74749
74750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
74751   void * jresult ;
74752   Dali::Toolkit::ItemView *arg1 = 0 ;
74753   Dali::Toolkit::ItemView *result = 0 ;
74754
74755   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74756   if (!arg1) {
74757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74758     return 0;
74759   }
74760   {
74761     try {
74762       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
74763     } catch (std::out_of_range& e) {
74764       {
74765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74766       };
74767     } catch (std::exception& e) {
74768       {
74769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74770       };
74771     } catch (Dali::DaliException e) {
74772       {
74773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74774       };
74775     } catch (...) {
74776       {
74777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74778       };
74779     }
74780   }
74781
74782   jresult = (void *)result;
74783   return jresult;
74784 }
74785
74786
74787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
74788   void * jresult ;
74789   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74790   Dali::Toolkit::ItemView *arg2 = 0 ;
74791   Dali::Toolkit::ItemView *result = 0 ;
74792
74793   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74794   arg2 = (Dali::Toolkit::ItemView *)jarg2;
74795   if (!arg2) {
74796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74797     return 0;
74798   }
74799   {
74800     try {
74801       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
74802     } catch (std::out_of_range& e) {
74803       {
74804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74805       };
74806     } catch (std::exception& e) {
74807       {
74808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74809       };
74810     } catch (Dali::DaliException e) {
74811       {
74812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74813       };
74814     } catch (...) {
74815       {
74816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74817       };
74818     }
74819   }
74820
74821   jresult = (void *)result;
74822   return jresult;
74823 }
74824
74825
74826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
74827   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74828
74829   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74830   {
74831     try {
74832       delete arg1;
74833     } catch (std::out_of_range& e) {
74834       {
74835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74836       };
74837     } catch (std::exception& e) {
74838       {
74839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74840       };
74841     } catch (Dali::DaliException e) {
74842       {
74843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74844       };
74845     } catch (...) {
74846       {
74847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74848       };
74849     }
74850   }
74851
74852 }
74853
74854
74855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
74856   void * jresult ;
74857   Dali::Toolkit::ItemFactory *arg1 = 0 ;
74858   Dali::Toolkit::ItemView result;
74859
74860   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74861   if (!arg1) {
74862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
74863     return 0;
74864   }
74865   {
74866     try {
74867       result = Dali::Toolkit::ItemView::New(*arg1);
74868     } catch (std::out_of_range& e) {
74869       {
74870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74871       };
74872     } catch (std::exception& e) {
74873       {
74874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74875       };
74876     } catch (Dali::DaliException e) {
74877       {
74878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74879       };
74880     } catch (...) {
74881       {
74882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74883       };
74884     }
74885   }
74886
74887   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
74888   return jresult;
74889 }
74890
74891
74892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
74893   void * jresult ;
74894   Dali::BaseHandle arg1 ;
74895   Dali::BaseHandle *argp1 ;
74896   Dali::Toolkit::ItemView result;
74897
74898   argp1 = (Dali::BaseHandle *)jarg1;
74899   if (!argp1) {
74900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74901     return 0;
74902   }
74903   arg1 = *argp1;
74904   {
74905     try {
74906       result = Dali::Toolkit::ItemView::DownCast(arg1);
74907     } catch (std::out_of_range& e) {
74908       {
74909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74910       };
74911     } catch (std::exception& e) {
74912       {
74913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74914       };
74915     } catch (Dali::DaliException e) {
74916       {
74917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74918       };
74919     } catch (...) {
74920       {
74921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74922       };
74923     }
74924   }
74925
74926   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
74927   return jresult;
74928 }
74929
74930
74931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
74932   unsigned int jresult ;
74933   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74934   unsigned int result;
74935
74936   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74937   {
74938     try {
74939       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
74940     } catch (std::out_of_range& e) {
74941       {
74942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74943       };
74944     } catch (std::exception& e) {
74945       {
74946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74947       };
74948     } catch (Dali::DaliException e) {
74949       {
74950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74951       };
74952     } catch (...) {
74953       {
74954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74955       };
74956     }
74957   }
74958
74959   jresult = result;
74960   return jresult;
74961 }
74962
74963
74964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
74965   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74966   Dali::Toolkit::ItemLayout *arg2 = 0 ;
74967
74968   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74969   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
74970   if (!arg2) {
74971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
74972     return ;
74973   }
74974   {
74975     try {
74976       (arg1)->AddLayout(*arg2);
74977     } catch (std::out_of_range& e) {
74978       {
74979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74980       };
74981     } catch (std::exception& e) {
74982       {
74983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74984       };
74985     } catch (Dali::DaliException e) {
74986       {
74987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74988       };
74989     } catch (...) {
74990       {
74991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74992       };
74993     }
74994   }
74995
74996 }
74997
74998
74999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
75000   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75001   unsigned int arg2 ;
75002
75003   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75004   arg2 = (unsigned int)jarg2;
75005   {
75006     try {
75007       (arg1)->RemoveLayout(arg2);
75008     } catch (std::out_of_range& e) {
75009       {
75010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75011       };
75012     } catch (std::exception& e) {
75013       {
75014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75015       };
75016     } catch (Dali::DaliException e) {
75017       {
75018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75019       };
75020     } catch (...) {
75021       {
75022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75023       };
75024     }
75025   }
75026
75027 }
75028
75029
75030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
75031   void * jresult ;
75032   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75033   unsigned int arg2 ;
75034   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75035
75036   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75037   arg2 = (unsigned int)jarg2;
75038   {
75039     try {
75040       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
75041     } catch (std::out_of_range& e) {
75042       {
75043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75044       };
75045     } catch (std::exception& e) {
75046       {
75047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75048       };
75049     } catch (Dali::DaliException e) {
75050       {
75051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75052       };
75053     } catch (...) {
75054       {
75055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75056       };
75057     }
75058   }
75059
75060   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75061   return jresult;
75062 }
75063
75064
75065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
75066   void * jresult ;
75067   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75068   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75069
75070   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75071   {
75072     try {
75073       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
75074     } catch (std::out_of_range& e) {
75075       {
75076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75077       };
75078     } catch (std::exception& e) {
75079       {
75080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75081       };
75082     } catch (Dali::DaliException e) {
75083       {
75084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75085       };
75086     } catch (...) {
75087       {
75088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75089       };
75090     }
75091   }
75092
75093   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75094   return jresult;
75095 }
75096
75097
75098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
75099   float jresult ;
75100   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75101   Dali::Toolkit::ItemId arg2 ;
75102   float result;
75103
75104   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75105   arg2 = (Dali::Toolkit::ItemId)jarg2;
75106   {
75107     try {
75108       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
75109     } catch (std::out_of_range& e) {
75110       {
75111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75112       };
75113     } catch (std::exception& e) {
75114       {
75115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75116       };
75117     } catch (Dali::DaliException e) {
75118       {
75119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75120       };
75121     } catch (...) {
75122       {
75123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75124       };
75125     }
75126   }
75127
75128   jresult = result;
75129   return jresult;
75130 }
75131
75132
75133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
75134   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75135   unsigned int arg2 ;
75136   Dali::Vector3 arg3 ;
75137   float arg4 ;
75138   Dali::Vector3 *argp3 ;
75139
75140   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75141   arg2 = (unsigned int)jarg2;
75142   argp3 = (Dali::Vector3 *)jarg3;
75143   if (!argp3) {
75144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75145     return ;
75146   }
75147   arg3 = *argp3;
75148   arg4 = (float)jarg4;
75149   {
75150     try {
75151       (arg1)->ActivateLayout(arg2,arg3,arg4);
75152     } catch (std::out_of_range& e) {
75153       {
75154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75155       };
75156     } catch (std::exception& e) {
75157       {
75158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75159       };
75160     } catch (Dali::DaliException e) {
75161       {
75162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75163       };
75164     } catch (...) {
75165       {
75166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75167       };
75168     }
75169   }
75170
75171 }
75172
75173
75174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
75175   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75176
75177   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75178   {
75179     try {
75180       (arg1)->DeactivateCurrentLayout();
75181     } catch (std::out_of_range& e) {
75182       {
75183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75184       };
75185     } catch (std::exception& e) {
75186       {
75187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75188       };
75189     } catch (Dali::DaliException e) {
75190       {
75191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75192       };
75193     } catch (...) {
75194       {
75195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75196       };
75197     }
75198   }
75199
75200 }
75201
75202
75203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
75204   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75205   float arg2 ;
75206
75207   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75208   arg2 = (float)jarg2;
75209   {
75210     try {
75211       (arg1)->SetMinimumSwipeSpeed(arg2);
75212     } catch (std::out_of_range& e) {
75213       {
75214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75215       };
75216     } catch (std::exception& e) {
75217       {
75218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75219       };
75220     } catch (Dali::DaliException e) {
75221       {
75222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75223       };
75224     } catch (...) {
75225       {
75226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75227       };
75228     }
75229   }
75230
75231 }
75232
75233
75234 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
75235   float jresult ;
75236   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75237   float result;
75238
75239   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75240   {
75241     try {
75242       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
75243     } catch (std::out_of_range& e) {
75244       {
75245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75246       };
75247     } catch (std::exception& e) {
75248       {
75249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75250       };
75251     } catch (Dali::DaliException e) {
75252       {
75253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75254       };
75255     } catch (...) {
75256       {
75257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75258       };
75259     }
75260   }
75261
75262   jresult = result;
75263   return jresult;
75264 }
75265
75266
75267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
75268   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75269   float arg2 ;
75270
75271   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75272   arg2 = (float)jarg2;
75273   {
75274     try {
75275       (arg1)->SetMinimumSwipeDistance(arg2);
75276     } catch (std::out_of_range& e) {
75277       {
75278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75279       };
75280     } catch (std::exception& e) {
75281       {
75282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75283       };
75284     } catch (Dali::DaliException e) {
75285       {
75286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75287       };
75288     } catch (...) {
75289       {
75290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75291       };
75292     }
75293   }
75294
75295 }
75296
75297
75298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
75299   float jresult ;
75300   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75301   float result;
75302
75303   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75304   {
75305     try {
75306       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
75307     } catch (std::out_of_range& e) {
75308       {
75309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75310       };
75311     } catch (std::exception& e) {
75312       {
75313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75314       };
75315     } catch (Dali::DaliException e) {
75316       {
75317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75318       };
75319     } catch (...) {
75320       {
75321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75322       };
75323     }
75324   }
75325
75326   jresult = result;
75327   return jresult;
75328 }
75329
75330
75331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
75332   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75333   float arg2 ;
75334
75335   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75336   arg2 = (float)jarg2;
75337   {
75338     try {
75339       (arg1)->SetWheelScrollDistanceStep(arg2);
75340     } catch (std::out_of_range& e) {
75341       {
75342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75343       };
75344     } catch (std::exception& e) {
75345       {
75346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75347       };
75348     } catch (Dali::DaliException e) {
75349       {
75350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75351       };
75352     } catch (...) {
75353       {
75354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75355       };
75356     }
75357   }
75358
75359 }
75360
75361
75362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
75363   float jresult ;
75364   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75365   float result;
75366
75367   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75368   {
75369     try {
75370       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
75371     } catch (std::out_of_range& e) {
75372       {
75373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75374       };
75375     } catch (std::exception& e) {
75376       {
75377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75378       };
75379     } catch (Dali::DaliException e) {
75380       {
75381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75382       };
75383     } catch (...) {
75384       {
75385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75386       };
75387     }
75388   }
75389
75390   jresult = result;
75391   return jresult;
75392 }
75393
75394
75395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
75396   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75397   bool arg2 ;
75398
75399   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75400   arg2 = jarg2 ? true : false;
75401   {
75402     try {
75403       (arg1)->SetAnchoring(arg2);
75404     } catch (std::out_of_range& e) {
75405       {
75406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75407       };
75408     } catch (std::exception& e) {
75409       {
75410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75411       };
75412     } catch (Dali::DaliException e) {
75413       {
75414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75415       };
75416     } catch (...) {
75417       {
75418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75419       };
75420     }
75421   }
75422
75423 }
75424
75425 //// ========================= end of part 3 =============================
75426
75427 //// ========================== start part 4 ===============================
75428
75429
75430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
75431   unsigned int jresult ;
75432   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75433   bool result;
75434
75435   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75436   {
75437     try {
75438       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
75439     } catch (std::out_of_range& e) {
75440       {
75441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75442       };
75443     } catch (std::exception& e) {
75444       {
75445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75446       };
75447     } catch (Dali::DaliException e) {
75448       {
75449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75450       };
75451     } catch (...) {
75452       {
75453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75454       };
75455     }
75456   }
75457
75458   jresult = result;
75459   return jresult;
75460 }
75461
75462
75463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
75464   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75465   float arg2 ;
75466
75467   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75468   arg2 = (float)jarg2;
75469   {
75470     try {
75471       (arg1)->SetAnchoringDuration(arg2);
75472     } catch (std::out_of_range& e) {
75473       {
75474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75475       };
75476     } catch (std::exception& e) {
75477       {
75478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75479       };
75480     } catch (Dali::DaliException e) {
75481       {
75482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75483       };
75484     } catch (...) {
75485       {
75486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75487       };
75488     }
75489   }
75490
75491 }
75492
75493
75494 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
75495   float jresult ;
75496   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75497   float result;
75498
75499   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75500   {
75501     try {
75502       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
75503     } catch (std::out_of_range& e) {
75504       {
75505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75506       };
75507     } catch (std::exception& e) {
75508       {
75509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75510       };
75511     } catch (Dali::DaliException e) {
75512       {
75513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75514       };
75515     } catch (...) {
75516       {
75517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75518       };
75519     }
75520   }
75521
75522   jresult = result;
75523   return jresult;
75524 }
75525
75526
75527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
75528   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75529   Dali::Toolkit::ItemId arg2 ;
75530   float arg3 ;
75531
75532   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75533   arg2 = (Dali::Toolkit::ItemId)jarg2;
75534   arg3 = (float)jarg3;
75535   {
75536     try {
75537       (arg1)->ScrollToItem(arg2,arg3);
75538     } catch (std::out_of_range& e) {
75539       {
75540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75541       };
75542     } catch (std::exception& e) {
75543       {
75544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75545       };
75546     } catch (Dali::DaliException e) {
75547       {
75548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75549       };
75550     } catch (...) {
75551       {
75552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75553       };
75554     }
75555   }
75556
75557 }
75558
75559
75560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
75561   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75562   float arg2 ;
75563
75564   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75565   arg2 = (float)jarg2;
75566   {
75567     try {
75568       (arg1)->SetRefreshInterval(arg2);
75569     } catch (std::out_of_range& e) {
75570       {
75571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75572       };
75573     } catch (std::exception& e) {
75574       {
75575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75576       };
75577     } catch (Dali::DaliException e) {
75578       {
75579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75580       };
75581     } catch (...) {
75582       {
75583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75584       };
75585     }
75586   }
75587
75588 }
75589
75590
75591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
75592   float jresult ;
75593   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75594   float result;
75595
75596   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75597   {
75598     try {
75599       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
75600     } catch (std::out_of_range& e) {
75601       {
75602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75603       };
75604     } catch (std::exception& e) {
75605       {
75606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75607       };
75608     } catch (Dali::DaliException e) {
75609       {
75610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75611       };
75612     } catch (...) {
75613       {
75614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75615       };
75616     }
75617   }
75618
75619   jresult = result;
75620   return jresult;
75621 }
75622
75623
75624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
75625   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75626
75627   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75628   {
75629     try {
75630       (arg1)->Refresh();
75631     } catch (std::out_of_range& e) {
75632       {
75633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75634       };
75635     } catch (std::exception& e) {
75636       {
75637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75638       };
75639     } catch (Dali::DaliException e) {
75640       {
75641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75642       };
75643     } catch (...) {
75644       {
75645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75646       };
75647     }
75648   }
75649
75650 }
75651
75652
75653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
75654   void * jresult ;
75655   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75656   Dali::Toolkit::ItemId arg2 ;
75657   Dali::Actor result;
75658
75659   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75660   arg2 = (Dali::Toolkit::ItemId)jarg2;
75661   {
75662     try {
75663       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
75664     } catch (std::out_of_range& e) {
75665       {
75666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75667       };
75668     } catch (std::exception& e) {
75669       {
75670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75671       };
75672     } catch (Dali::DaliException e) {
75673       {
75674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75675       };
75676     } catch (...) {
75677       {
75678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75679       };
75680     }
75681   }
75682
75683   jresult = new Dali::Actor((const Dali::Actor &)result);
75684   return jresult;
75685 }
75686
75687
75688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
75689   unsigned int jresult ;
75690   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75691   Dali::Actor arg2 ;
75692   Dali::Actor *argp2 ;
75693   Dali::Toolkit::ItemId result;
75694
75695   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75696   argp2 = (Dali::Actor *)jarg2;
75697   if (!argp2) {
75698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75699     return 0;
75700   }
75701   arg2 = *argp2;
75702   {
75703     try {
75704       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
75705     } catch (std::out_of_range& e) {
75706       {
75707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75708       };
75709     } catch (std::exception& e) {
75710       {
75711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75712       };
75713     } catch (Dali::DaliException e) {
75714       {
75715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75716       };
75717     } catch (...) {
75718       {
75719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75720       };
75721     }
75722   }
75723
75724   jresult = result;
75725   return jresult;
75726 }
75727
75728
75729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
75730   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75731   Dali::Toolkit::Item arg2 ;
75732   float arg3 ;
75733   Dali::Toolkit::Item *argp2 ;
75734
75735   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75736   argp2 = (Dali::Toolkit::Item *)jarg2;
75737   if (!argp2) {
75738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75739     return ;
75740   }
75741   arg2 = *argp2;
75742   arg3 = (float)jarg3;
75743   {
75744     try {
75745       (arg1)->InsertItem(arg2,arg3);
75746     } catch (std::out_of_range& e) {
75747       {
75748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75749       };
75750     } catch (std::exception& e) {
75751       {
75752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75753       };
75754     } catch (Dali::DaliException e) {
75755       {
75756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75757       };
75758     } catch (...) {
75759       {
75760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75761       };
75762     }
75763   }
75764
75765 }
75766
75767
75768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
75769   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75770   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75771   float arg3 ;
75772
75773   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75774   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
75775   if (!arg2) {
75776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
75777     return ;
75778   }
75779   arg3 = (float)jarg3;
75780   {
75781     try {
75782       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
75783     } catch (std::out_of_range& e) {
75784       {
75785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75786       };
75787     } catch (std::exception& e) {
75788       {
75789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75790       };
75791     } catch (Dali::DaliException e) {
75792       {
75793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75794       };
75795     } catch (...) {
75796       {
75797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75798       };
75799     }
75800   }
75801
75802 }
75803
75804
75805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
75806   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75807   Dali::Toolkit::ItemId arg2 ;
75808   float arg3 ;
75809
75810   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75811   arg2 = (Dali::Toolkit::ItemId)jarg2;
75812   arg3 = (float)jarg3;
75813   {
75814     try {
75815       (arg1)->RemoveItem(arg2,arg3);
75816     } catch (std::out_of_range& e) {
75817       {
75818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75819       };
75820     } catch (std::exception& e) {
75821       {
75822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75823       };
75824     } catch (Dali::DaliException e) {
75825       {
75826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75827       };
75828     } catch (...) {
75829       {
75830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75831       };
75832     }
75833   }
75834
75835 }
75836
75837
75838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
75839   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75840   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
75841   float arg3 ;
75842
75843   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75844   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
75845   if (!arg2) {
75846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
75847     return ;
75848   }
75849   arg3 = (float)jarg3;
75850   {
75851     try {
75852       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
75853     } catch (std::out_of_range& e) {
75854       {
75855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75856       };
75857     } catch (std::exception& e) {
75858       {
75859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75860       };
75861     } catch (Dali::DaliException e) {
75862       {
75863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75864       };
75865     } catch (...) {
75866       {
75867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75868       };
75869     }
75870   }
75871
75872 }
75873
75874
75875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
75876   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75877   Dali::Toolkit::Item arg2 ;
75878   float arg3 ;
75879   Dali::Toolkit::Item *argp2 ;
75880
75881   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75882   argp2 = (Dali::Toolkit::Item *)jarg2;
75883   if (!argp2) {
75884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75885     return ;
75886   }
75887   arg2 = *argp2;
75888   arg3 = (float)jarg3;
75889   {
75890     try {
75891       (arg1)->ReplaceItem(arg2,arg3);
75892     } catch (std::out_of_range& e) {
75893       {
75894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75895       };
75896     } catch (std::exception& e) {
75897       {
75898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75899       };
75900     } catch (Dali::DaliException e) {
75901       {
75902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75903       };
75904     } catch (...) {
75905       {
75906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75907       };
75908     }
75909   }
75910
75911 }
75912
75913
75914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
75915   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75916   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75917   float arg3 ;
75918
75919   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75920   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
75921   if (!arg2) {
75922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
75923     return ;
75924   }
75925   arg3 = (float)jarg3;
75926   {
75927     try {
75928       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
75929     } catch (std::out_of_range& e) {
75930       {
75931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75932       };
75933     } catch (std::exception& e) {
75934       {
75935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75936       };
75937     } catch (Dali::DaliException e) {
75938       {
75939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75940       };
75941     } catch (...) {
75942       {
75943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75944       };
75945     }
75946   }
75947
75948 }
75949
75950
75951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
75952   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75953   Dali::Vector3 *arg2 = 0 ;
75954
75955   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75956   arg2 = (Dali::Vector3 *)jarg2;
75957   if (!arg2) {
75958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75959     return ;
75960   }
75961   {
75962     try {
75963       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
75964     } catch (std::out_of_range& e) {
75965       {
75966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75967       };
75968     } catch (std::exception& e) {
75969       {
75970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75971       };
75972     } catch (Dali::DaliException e) {
75973       {
75974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75975       };
75976     } catch (...) {
75977       {
75978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75979       };
75980     }
75981   }
75982
75983 }
75984
75985
75986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
75987   void * jresult ;
75988   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75989   Dali::Vector3 result;
75990
75991   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75992   {
75993     try {
75994       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
75995     } catch (std::out_of_range& e) {
75996       {
75997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75998       };
75999     } catch (std::exception& e) {
76000       {
76001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76002       };
76003     } catch (Dali::DaliException e) {
76004       {
76005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76006       };
76007     } catch (...) {
76008       {
76009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76010       };
76011     }
76012   }
76013
76014   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76015   return jresult;
76016 }
76017
76018
76019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
76020   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76021   Dali::Vector3 *arg2 = 0 ;
76022
76023   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76024   arg2 = (Dali::Vector3 *)jarg2;
76025   if (!arg2) {
76026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76027     return ;
76028   }
76029   {
76030     try {
76031       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
76032     } catch (std::out_of_range& e) {
76033       {
76034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76035       };
76036     } catch (std::exception& e) {
76037       {
76038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76039       };
76040     } catch (Dali::DaliException e) {
76041       {
76042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76043       };
76044     } catch (...) {
76045       {
76046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76047       };
76048     }
76049   }
76050
76051 }
76052
76053
76054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
76055   void * jresult ;
76056   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76057   Dali::Vector3 result;
76058
76059   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76060   {
76061     try {
76062       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
76063     } catch (std::out_of_range& e) {
76064       {
76065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76066       };
76067     } catch (std::exception& e) {
76068       {
76069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76070       };
76071     } catch (Dali::DaliException e) {
76072       {
76073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76074       };
76075     } catch (...) {
76076       {
76077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76078       };
76079     }
76080   }
76081
76082   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76083   return jresult;
76084 }
76085
76086
76087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
76088   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76089   Dali::Toolkit::ItemRange *arg2 = 0 ;
76090
76091   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76092   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
76093   if (!arg2) {
76094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
76095     return ;
76096   }
76097   {
76098     try {
76099       (arg1)->GetItemsRange(*arg2);
76100     } catch (std::out_of_range& e) {
76101       {
76102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76103       };
76104     } catch (std::exception& e) {
76105       {
76106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76107       };
76108     } catch (Dali::DaliException e) {
76109       {
76110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76111       };
76112     } catch (...) {
76113       {
76114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76115       };
76116     }
76117   }
76118
76119 }
76120
76121
76122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
76123   void * jresult ;
76124   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76125   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
76126
76127   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76128   {
76129     try {
76130       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
76131     } catch (std::out_of_range& e) {
76132       {
76133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76134       };
76135     } catch (std::exception& e) {
76136       {
76137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76138       };
76139     } catch (Dali::DaliException e) {
76140       {
76141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76142       };
76143     } catch (...) {
76144       {
76145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76146       };
76147     }
76148   }
76149
76150   jresult = (void *)result;
76151   return jresult;
76152 }
76153
76154
76155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
76156   Dali::Vector3 *arg1 = 0 ;
76157   PropertyInputContainer *arg2 = 0 ;
76158
76159   arg1 = (Dali::Vector3 *)jarg1;
76160   if (!arg1) {
76161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
76162     return ;
76163   }
76164   arg2 = (PropertyInputContainer *)jarg2;
76165   if (!arg2) {
76166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
76167     return ;
76168   }
76169   {
76170     try {
76171       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
76172     } catch (std::out_of_range& e) {
76173       {
76174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76175       };
76176     } catch (std::exception& e) {
76177       {
76178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76179       };
76180     } catch (Dali::DaliException e) {
76181       {
76182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76183       };
76184     } catch (...) {
76185       {
76186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76187       };
76188     }
76189   }
76190
76191 }
76192
76193
76194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
76195   Dali::Vector3 *arg1 = 0 ;
76196   PropertyInputContainer *arg2 = 0 ;
76197
76198   arg1 = (Dali::Vector3 *)jarg1;
76199   if (!arg1) {
76200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
76201     return ;
76202   }
76203   arg2 = (PropertyInputContainer *)jarg2;
76204   if (!arg2) {
76205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
76206     return ;
76207   }
76208   {
76209     try {
76210       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
76211     } catch (std::out_of_range& e) {
76212       {
76213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76214       };
76215     } catch (std::exception& e) {
76216       {
76217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76218       };
76219     } catch (Dali::DaliException e) {
76220       {
76221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76222       };
76223     } catch (...) {
76224       {
76225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76226       };
76227     }
76228   }
76229
76230 }
76231
76232
76233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
76234   void * jresult ;
76235   Dali::Toolkit::ScrollViewEffect *result = 0 ;
76236
76237   {
76238     try {
76239       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
76240     } catch (std::out_of_range& e) {
76241       {
76242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76243       };
76244     } catch (std::exception& e) {
76245       {
76246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76247       };
76248     } catch (Dali::DaliException e) {
76249       {
76250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76251       };
76252     } catch (...) {
76253       {
76254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76255       };
76256     }
76257   }
76258
76259   jresult = (void *)result;
76260   return jresult;
76261 }
76262
76263
76264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
76265   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
76266
76267   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
76268   {
76269     try {
76270       delete arg1;
76271     } catch (std::out_of_range& e) {
76272       {
76273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76274       };
76275     } catch (std::exception& e) {
76276       {
76277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76278       };
76279     } catch (Dali::DaliException e) {
76280       {
76281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76282       };
76283     } catch (...) {
76284       {
76285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76286       };
76287     }
76288   }
76289
76290 }
76291
76292
76293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
76294   void * jresult ;
76295   Dali::Path arg1 ;
76296   Dali::Vector3 *arg2 = 0 ;
76297   Dali::Property::Index arg3 ;
76298   Dali::Vector3 *arg4 = 0 ;
76299   unsigned int arg5 ;
76300   Dali::Path *argp1 ;
76301   Dali::Toolkit::ScrollViewPagePathEffect result;
76302
76303   argp1 = (Dali::Path *)jarg1;
76304   if (!argp1) {
76305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
76306     return 0;
76307   }
76308   arg1 = *argp1;
76309   arg2 = (Dali::Vector3 *)jarg2;
76310   if (!arg2) {
76311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76312     return 0;
76313   }
76314   arg3 = (Dali::Property::Index)jarg3;
76315   arg4 = (Dali::Vector3 *)jarg4;
76316   if (!arg4) {
76317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76318     return 0;
76319   }
76320   arg5 = (unsigned int)jarg5;
76321   {
76322     try {
76323       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
76324     } catch (std::out_of_range& e) {
76325       {
76326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76327       };
76328     } catch (std::exception& e) {
76329       {
76330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76331       };
76332     } catch (Dali::DaliException e) {
76333       {
76334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76335       };
76336     } catch (...) {
76337       {
76338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76339       };
76340     }
76341   }
76342
76343   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76344   return jresult;
76345 }
76346
76347
76348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
76349   void * jresult ;
76350   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
76351
76352   {
76353     try {
76354       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
76355     } catch (std::out_of_range& e) {
76356       {
76357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76358       };
76359     } catch (std::exception& e) {
76360       {
76361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76362       };
76363     } catch (Dali::DaliException e) {
76364       {
76365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76366       };
76367     } catch (...) {
76368       {
76369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76370       };
76371     }
76372   }
76373
76374   jresult = (void *)result;
76375   return jresult;
76376 }
76377
76378
76379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
76380   void * jresult ;
76381   Dali::BaseHandle arg1 ;
76382   Dali::BaseHandle *argp1 ;
76383   Dali::Toolkit::ScrollViewPagePathEffect result;
76384
76385   argp1 = (Dali::BaseHandle *)jarg1;
76386   if (!argp1) {
76387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76388     return 0;
76389   }
76390   arg1 = *argp1;
76391   {
76392     try {
76393       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
76394     } catch (std::out_of_range& e) {
76395       {
76396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76397       };
76398     } catch (std::exception& e) {
76399       {
76400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76401       };
76402     } catch (Dali::DaliException e) {
76403       {
76404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76405       };
76406     } catch (...) {
76407       {
76408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76409       };
76410     }
76411   }
76412
76413   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76414   return jresult;
76415 }
76416
76417
76418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
76419   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76420   Dali::Actor arg2 ;
76421   unsigned int arg3 ;
76422   Dali::Actor *argp2 ;
76423
76424   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76425   argp2 = (Dali::Actor *)jarg2;
76426   if (!argp2) {
76427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76428     return ;
76429   }
76430   arg2 = *argp2;
76431   arg3 = (unsigned int)jarg3;
76432   {
76433     try {
76434       (arg1)->ApplyToPage(arg2,arg3);
76435     } catch (std::out_of_range& e) {
76436       {
76437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76438       };
76439     } catch (std::exception& e) {
76440       {
76441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76442       };
76443     } catch (Dali::DaliException e) {
76444       {
76445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76446       };
76447     } catch (...) {
76448       {
76449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76450       };
76451     }
76452   }
76453
76454 }
76455
76456
76457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
76458   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76459
76460   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76461   {
76462     try {
76463       delete arg1;
76464     } catch (std::out_of_range& e) {
76465       {
76466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76467       };
76468     } catch (std::exception& e) {
76469       {
76470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76471       };
76472     } catch (Dali::DaliException e) {
76473       {
76474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76475       };
76476     } catch (...) {
76477       {
76478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76479       };
76480     }
76481   }
76482
76483 }
76484
76485
76486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
76487   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76488   Dali::Toolkit::ClampState arg2 ;
76489
76490   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76491   arg2 = (Dali::Toolkit::ClampState)jarg2;
76492   if (arg1) (arg1)->x = arg2;
76493 }
76494
76495
76496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
76497   int jresult ;
76498   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76499   Dali::Toolkit::ClampState result;
76500
76501   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76502   result = (Dali::Toolkit::ClampState) ((arg1)->x);
76503   jresult = (int)result;
76504   return jresult;
76505 }
76506
76507
76508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
76509   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76510   Dali::Toolkit::ClampState arg2 ;
76511
76512   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76513   arg2 = (Dali::Toolkit::ClampState)jarg2;
76514   if (arg1) (arg1)->y = arg2;
76515 }
76516
76517
76518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
76519   int jresult ;
76520   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76521   Dali::Toolkit::ClampState result;
76522
76523   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76524   result = (Dali::Toolkit::ClampState) ((arg1)->y);
76525   jresult = (int)result;
76526   return jresult;
76527 }
76528
76529
76530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
76531   void * jresult ;
76532   Dali::Toolkit::ClampState2D *result = 0 ;
76533
76534   {
76535     try {
76536       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
76537     } catch (std::out_of_range& e) {
76538       {
76539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76540       };
76541     } catch (std::exception& e) {
76542       {
76543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76544       };
76545     } catch (Dali::DaliException e) {
76546       {
76547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76548       };
76549     } catch (...) {
76550       {
76551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76552       };
76553     }
76554   }
76555
76556   jresult = (void *)result;
76557   return jresult;
76558 }
76559
76560
76561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
76562   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76563
76564   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76565   {
76566     try {
76567       delete arg1;
76568     } catch (std::out_of_range& e) {
76569       {
76570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76571       };
76572     } catch (std::exception& e) {
76573       {
76574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76575       };
76576     } catch (Dali::DaliException e) {
76577       {
76578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76579       };
76580     } catch (...) {
76581       {
76582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76583       };
76584     }
76585   }
76586
76587 }
76588
76589
76590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
76591   void * jresult ;
76592   float arg1 ;
76593   float arg2 ;
76594   bool arg3 ;
76595   Dali::Toolkit::RulerDomain *result = 0 ;
76596
76597   arg1 = (float)jarg1;
76598   arg2 = (float)jarg2;
76599   arg3 = jarg3 ? true : false;
76600   {
76601     try {
76602       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
76603     } catch (std::out_of_range& e) {
76604       {
76605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76606       };
76607     } catch (std::exception& e) {
76608       {
76609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76610       };
76611     } catch (Dali::DaliException e) {
76612       {
76613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76614       };
76615     } catch (...) {
76616       {
76617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76618       };
76619     }
76620   }
76621
76622   jresult = (void *)result;
76623   return jresult;
76624 }
76625
76626
76627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
76628   void * jresult ;
76629   float arg1 ;
76630   float arg2 ;
76631   Dali::Toolkit::RulerDomain *result = 0 ;
76632
76633   arg1 = (float)jarg1;
76634   arg2 = (float)jarg2;
76635   {
76636     try {
76637       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,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 = (void *)result;
76658   return jresult;
76659 }
76660
76661
76662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
76663   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76664   float arg2 ;
76665
76666   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76667   arg2 = (float)jarg2;
76668   if (arg1) (arg1)->min = arg2;
76669 }
76670
76671
76672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
76673   float jresult ;
76674   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76675   float result;
76676
76677   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76678   result = (float) ((arg1)->min);
76679   jresult = result;
76680   return jresult;
76681 }
76682
76683
76684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
76685   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76686   float arg2 ;
76687
76688   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76689   arg2 = (float)jarg2;
76690   if (arg1) (arg1)->max = arg2;
76691 }
76692
76693
76694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
76695   float jresult ;
76696   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76697   float result;
76698
76699   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76700   result = (float) ((arg1)->max);
76701   jresult = result;
76702   return jresult;
76703 }
76704
76705
76706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
76707   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76708   bool arg2 ;
76709
76710   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76711   arg2 = jarg2 ? true : false;
76712   if (arg1) (arg1)->enabled = arg2;
76713 }
76714
76715
76716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
76717   unsigned int jresult ;
76718   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76719   bool result;
76720
76721   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76722   result = (bool) ((arg1)->enabled);
76723   jresult = result;
76724   return jresult;
76725 }
76726
76727
76728 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
76729   float jresult ;
76730   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76731   float arg2 ;
76732   float arg3 ;
76733   float arg4 ;
76734   float result;
76735
76736   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76737   arg2 = (float)jarg2;
76738   arg3 = (float)jarg3;
76739   arg4 = (float)jarg4;
76740   {
76741     try {
76742       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
76743     } catch (std::out_of_range& e) {
76744       {
76745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76746       };
76747     } catch (std::exception& e) {
76748       {
76749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76750       };
76751     } catch (Dali::DaliException e) {
76752       {
76753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76754       };
76755     } catch (...) {
76756       {
76757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76758       };
76759     }
76760   }
76761
76762   jresult = result;
76763   return jresult;
76764 }
76765
76766
76767 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
76768   float jresult ;
76769   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76770   float arg2 ;
76771   float arg3 ;
76772   float result;
76773
76774   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76775   arg2 = (float)jarg2;
76776   arg3 = (float)jarg3;
76777   {
76778     try {
76779       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
76780     } catch (std::out_of_range& e) {
76781       {
76782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76783       };
76784     } catch (std::exception& e) {
76785       {
76786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76787       };
76788     } catch (Dali::DaliException e) {
76789       {
76790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76791       };
76792     } catch (...) {
76793       {
76794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76795       };
76796     }
76797   }
76798
76799   jresult = result;
76800   return jresult;
76801 }
76802
76803
76804 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
76805   float jresult ;
76806   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76807   float arg2 ;
76808   float result;
76809
76810   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76811   arg2 = (float)jarg2;
76812   {
76813     try {
76814       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
76815     } catch (std::out_of_range& e) {
76816       {
76817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76818       };
76819     } catch (std::exception& e) {
76820       {
76821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76822       };
76823     } catch (Dali::DaliException e) {
76824       {
76825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76826       };
76827     } catch (...) {
76828       {
76829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76830       };
76831     }
76832   }
76833
76834   jresult = result;
76835   return jresult;
76836 }
76837
76838
76839 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
76840   float jresult ;
76841   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76842   float arg2 ;
76843   float arg3 ;
76844   float arg4 ;
76845   Dali::Toolkit::ClampState *arg5 = 0 ;
76846   float result;
76847
76848   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76849   arg2 = (float)jarg2;
76850   arg3 = (float)jarg3;
76851   arg4 = (float)jarg4;
76852   arg5 = (Dali::Toolkit::ClampState *)jarg5;
76853   if (!arg5) {
76854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
76855     return 0;
76856   }
76857   {
76858     try {
76859       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
76860     } catch (std::out_of_range& e) {
76861       {
76862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76863       };
76864     } catch (std::exception& e) {
76865       {
76866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76867       };
76868     } catch (Dali::DaliException e) {
76869       {
76870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76871       };
76872     } catch (...) {
76873       {
76874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76875       };
76876     }
76877   }
76878
76879   jresult = result;
76880   return jresult;
76881 }
76882
76883
76884 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
76885   float jresult ;
76886   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76887   float result;
76888
76889   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76890   {
76891     try {
76892       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
76893     } catch (std::out_of_range& e) {
76894       {
76895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76896       };
76897     } catch (std::exception& e) {
76898       {
76899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76900       };
76901     } catch (Dali::DaliException e) {
76902       {
76903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76904       };
76905     } catch (...) {
76906       {
76907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76908       };
76909     }
76910   }
76911
76912   jresult = result;
76913   return jresult;
76914 }
76915
76916
76917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
76918   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76919
76920   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76921   {
76922     try {
76923       delete arg1;
76924     } catch (std::out_of_range& e) {
76925       {
76926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76927       };
76928     } catch (std::exception& e) {
76929       {
76930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76931       };
76932     } catch (Dali::DaliException e) {
76933       {
76934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76935       };
76936     } catch (...) {
76937       {
76938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76939       };
76940     }
76941   }
76942
76943 }
76944
76945
76946 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
76947   float jresult ;
76948   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76949   float arg2 ;
76950   float arg3 ;
76951   float result;
76952
76953   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76954   arg2 = (float)jarg2;
76955   arg3 = (float)jarg3;
76956   {
76957     try {
76958       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
76959     } catch (std::out_of_range& e) {
76960       {
76961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76962       };
76963     } catch (std::exception& e) {
76964       {
76965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76966       };
76967     } catch (Dali::DaliException e) {
76968       {
76969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76970       };
76971     } catch (...) {
76972       {
76973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76974       };
76975     }
76976   }
76977
76978   jresult = result;
76979   return jresult;
76980 }
76981
76982
76983 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
76984   float jresult ;
76985   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76986   float arg2 ;
76987   float result;
76988
76989   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76990   arg2 = (float)jarg2;
76991   {
76992     try {
76993       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
76994     } catch (std::out_of_range& e) {
76995       {
76996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76997       };
76998     } catch (std::exception& e) {
76999       {
77000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77001       };
77002     } catch (Dali::DaliException e) {
77003       {
77004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77005       };
77006     } catch (...) {
77007       {
77008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77009       };
77010     }
77011   }
77012
77013   jresult = result;
77014   return jresult;
77015 }
77016
77017
77018 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77019   float jresult ;
77020   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77021   unsigned int arg2 ;
77022   unsigned int *arg3 = 0 ;
77023   bool arg4 ;
77024   float result;
77025
77026   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77027   arg2 = (unsigned int)jarg2;
77028   arg3 = (unsigned int *)jarg3;
77029   arg4 = jarg4 ? true : false;
77030   {
77031     try {
77032       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77033     } catch (std::out_of_range& e) {
77034       {
77035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77036       };
77037     } catch (std::exception& e) {
77038       {
77039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77040       };
77041     } catch (Dali::DaliException e) {
77042       {
77043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77044       };
77045     } catch (...) {
77046       {
77047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77048       };
77049     }
77050   }
77051
77052   jresult = result;
77053   return jresult;
77054 }
77055
77056
77057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77058   unsigned int jresult ;
77059   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77060   float arg2 ;
77061   bool arg3 ;
77062   unsigned int result;
77063
77064   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77065   arg2 = (float)jarg2;
77066   arg3 = jarg3 ? true : false;
77067   {
77068     try {
77069       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
77070     } catch (std::out_of_range& e) {
77071       {
77072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77073       };
77074     } catch (std::exception& e) {
77075       {
77076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77077       };
77078     } catch (Dali::DaliException e) {
77079       {
77080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77081       };
77082     } catch (...) {
77083       {
77084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77085       };
77086     }
77087   }
77088
77089   jresult = result;
77090   return jresult;
77091 }
77092
77093
77094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
77095   unsigned int jresult ;
77096   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77097   unsigned int result;
77098
77099   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77100   {
77101     try {
77102       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
77103     } catch (std::out_of_range& e) {
77104       {
77105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77106       };
77107     } catch (std::exception& e) {
77108       {
77109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77110       };
77111     } catch (Dali::DaliException e) {
77112       {
77113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77114       };
77115     } catch (...) {
77116       {
77117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77118       };
77119     }
77120   }
77121
77122   jresult = result;
77123   return jresult;
77124 }
77125
77126
77127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
77128   int jresult ;
77129   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77130   Dali::Toolkit::Ruler::RulerType result;
77131
77132   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77133   {
77134     try {
77135       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
77136     } catch (std::out_of_range& e) {
77137       {
77138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77139       };
77140     } catch (std::exception& e) {
77141       {
77142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77143       };
77144     } catch (Dali::DaliException e) {
77145       {
77146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77147       };
77148     } catch (...) {
77149       {
77150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77151       };
77152     }
77153   }
77154
77155   jresult = (int)result;
77156   return jresult;
77157 }
77158
77159
77160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
77161   unsigned int jresult ;
77162   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77163   bool result;
77164
77165   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77166   {
77167     try {
77168       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
77169     } catch (std::out_of_range& e) {
77170       {
77171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77172       };
77173     } catch (std::exception& e) {
77174       {
77175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77176       };
77177     } catch (Dali::DaliException e) {
77178       {
77179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77180       };
77181     } catch (...) {
77182       {
77183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77184       };
77185     }
77186   }
77187
77188   jresult = result;
77189   return jresult;
77190 }
77191
77192
77193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
77194   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77195
77196   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77197   {
77198     try {
77199       (arg1)->Enable();
77200     } catch (std::out_of_range& e) {
77201       {
77202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77203       };
77204     } catch (std::exception& e) {
77205       {
77206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77207       };
77208     } catch (Dali::DaliException e) {
77209       {
77210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77211       };
77212     } catch (...) {
77213       {
77214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77215       };
77216     }
77217   }
77218
77219 }
77220
77221
77222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
77223   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77224
77225   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77226   {
77227     try {
77228       (arg1)->Disable();
77229     } catch (std::out_of_range& e) {
77230       {
77231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77232       };
77233     } catch (std::exception& e) {
77234       {
77235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77236       };
77237     } catch (Dali::DaliException e) {
77238       {
77239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77240       };
77241     } catch (...) {
77242       {
77243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77244       };
77245     }
77246   }
77247
77248 }
77249
77250
77251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
77252   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77253   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
77254   Dali::Toolkit::RulerDomain *argp2 ;
77255
77256   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77257   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
77258   if (!argp2) {
77259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
77260     return ;
77261   }
77262   arg2 = *argp2;
77263   {
77264     try {
77265       (arg1)->SetDomain(arg2);
77266     } catch (std::out_of_range& e) {
77267       {
77268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77269       };
77270     } catch (std::exception& e) {
77271       {
77272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77273       };
77274     } catch (Dali::DaliException e) {
77275       {
77276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77277       };
77278     } catch (...) {
77279       {
77280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77281       };
77282     }
77283   }
77284
77285 }
77286
77287
77288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
77289   void * jresult ;
77290   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77291   Dali::Toolkit::RulerDomain *result = 0 ;
77292
77293   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77294   {
77295     try {
77296       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
77297     } catch (std::out_of_range& e) {
77298       {
77299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77300       };
77301     } catch (std::exception& e) {
77302       {
77303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77304       };
77305     } catch (Dali::DaliException e) {
77306       {
77307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77308       };
77309     } catch (...) {
77310       {
77311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77312       };
77313     }
77314   }
77315
77316   jresult = (void *)result;
77317   return jresult;
77318 }
77319
77320
77321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
77322   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77323
77324   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77325   {
77326     try {
77327       (arg1)->DisableDomain();
77328     } catch (std::out_of_range& e) {
77329       {
77330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77331       };
77332     } catch (std::exception& e) {
77333       {
77334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77335       };
77336     } catch (Dali::DaliException e) {
77337       {
77338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77339       };
77340     } catch (...) {
77341       {
77342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77343       };
77344     }
77345   }
77346
77347 }
77348
77349
77350 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77351   float jresult ;
77352   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77353   float arg2 ;
77354   float arg3 ;
77355   float arg4 ;
77356   float result;
77357
77358   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77359   arg2 = (float)jarg2;
77360   arg3 = (float)jarg3;
77361   arg4 = (float)jarg4;
77362   {
77363     try {
77364       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
77365     } catch (std::out_of_range& e) {
77366       {
77367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77368       };
77369     } catch (std::exception& e) {
77370       {
77371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77372       };
77373     } catch (Dali::DaliException e) {
77374       {
77375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77376       };
77377     } catch (...) {
77378       {
77379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77380       };
77381     }
77382   }
77383
77384   jresult = result;
77385   return jresult;
77386 }
77387
77388
77389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77390   float jresult ;
77391   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77392   float arg2 ;
77393   float arg3 ;
77394   float result;
77395
77396   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77397   arg2 = (float)jarg2;
77398   arg3 = (float)jarg3;
77399   {
77400     try {
77401       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
77402     } catch (std::out_of_range& e) {
77403       {
77404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77405       };
77406     } catch (std::exception& e) {
77407       {
77408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77409       };
77410     } catch (Dali::DaliException e) {
77411       {
77412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77413       };
77414     } catch (...) {
77415       {
77416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77417       };
77418     }
77419   }
77420
77421   jresult = result;
77422   return jresult;
77423 }
77424
77425
77426 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
77427   float jresult ;
77428   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77429   float arg2 ;
77430   float result;
77431
77432   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77433   arg2 = (float)jarg2;
77434   {
77435     try {
77436       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
77437     } catch (std::out_of_range& e) {
77438       {
77439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77440       };
77441     } catch (std::exception& e) {
77442       {
77443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77444       };
77445     } catch (Dali::DaliException e) {
77446       {
77447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77448       };
77449     } catch (...) {
77450       {
77451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77452       };
77453     }
77454   }
77455
77456   jresult = result;
77457   return jresult;
77458 }
77459
77460
77461 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77462   float jresult ;
77463   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77464   float arg2 ;
77465   float arg3 ;
77466   float arg4 ;
77467   Dali::Toolkit::ClampState *arg5 = 0 ;
77468   float result;
77469
77470   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77471   arg2 = (float)jarg2;
77472   arg3 = (float)jarg3;
77473   arg4 = (float)jarg4;
77474   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77475   if (!arg5) {
77476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77477     return 0;
77478   }
77479   {
77480     try {
77481       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
77482     } catch (std::out_of_range& e) {
77483       {
77484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77485       };
77486     } catch (std::exception& e) {
77487       {
77488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77489       };
77490     } catch (Dali::DaliException e) {
77491       {
77492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77493       };
77494     } catch (...) {
77495       {
77496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77497       };
77498     }
77499   }
77500
77501   jresult = result;
77502   return jresult;
77503 }
77504
77505
77506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
77507   float jresult ;
77508   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77509   float arg2 ;
77510   float arg3 ;
77511   float arg4 ;
77512   float arg5 ;
77513   float result;
77514
77515   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77516   arg2 = (float)jarg2;
77517   arg3 = (float)jarg3;
77518   arg4 = (float)jarg4;
77519   arg5 = (float)jarg5;
77520   {
77521     try {
77522       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
77523     } catch (std::out_of_range& e) {
77524       {
77525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77526       };
77527     } catch (std::exception& e) {
77528       {
77529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77530       };
77531     } catch (Dali::DaliException e) {
77532       {
77533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77534       };
77535     } catch (...) {
77536       {
77537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77538       };
77539     }
77540   }
77541
77542   jresult = result;
77543   return jresult;
77544 }
77545
77546
77547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
77548   float jresult ;
77549   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77550   float arg2 ;
77551   float arg3 ;
77552   float arg4 ;
77553   float result;
77554
77555   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77556   arg2 = (float)jarg2;
77557   arg3 = (float)jarg3;
77558   arg4 = (float)jarg4;
77559   {
77560     try {
77561       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
77562     } catch (std::out_of_range& e) {
77563       {
77564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77565       };
77566     } catch (std::exception& e) {
77567       {
77568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77569       };
77570     } catch (Dali::DaliException e) {
77571       {
77572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77573       };
77574     } catch (...) {
77575       {
77576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77577       };
77578     }
77579   }
77580
77581   jresult = result;
77582   return jresult;
77583 }
77584
77585
77586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
77587   float jresult ;
77588   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77589   float arg2 ;
77590   float arg3 ;
77591   float result;
77592
77593   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77594   arg2 = (float)jarg2;
77595   arg3 = (float)jarg3;
77596   {
77597     try {
77598       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
77599     } catch (std::out_of_range& e) {
77600       {
77601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77602       };
77603     } catch (std::exception& e) {
77604       {
77605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77606       };
77607     } catch (Dali::DaliException e) {
77608       {
77609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77610       };
77611     } catch (...) {
77612       {
77613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77614       };
77615     }
77616   }
77617
77618   jresult = result;
77619   return jresult;
77620 }
77621
77622
77623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
77624   float jresult ;
77625   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77626   float arg2 ;
77627   float result;
77628
77629   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77630   arg2 = (float)jarg2;
77631   {
77632     try {
77633       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
77634     } catch (std::out_of_range& e) {
77635       {
77636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77637       };
77638     } catch (std::exception& e) {
77639       {
77640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77641       };
77642     } catch (Dali::DaliException e) {
77643       {
77644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77645       };
77646     } catch (...) {
77647       {
77648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77649       };
77650     }
77651   }
77652
77653   jresult = result;
77654   return jresult;
77655 }
77656
77657
77658 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
77659   float jresult ;
77660   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77661   float arg2 ;
77662   float arg3 ;
77663   float arg4 ;
77664   float arg5 ;
77665   Dali::Toolkit::ClampState *arg6 = 0 ;
77666   float result;
77667
77668   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77669   arg2 = (float)jarg2;
77670   arg3 = (float)jarg3;
77671   arg4 = (float)jarg4;
77672   arg5 = (float)jarg5;
77673   arg6 = (Dali::Toolkit::ClampState *)jarg6;
77674   if (!arg6) {
77675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77676     return 0;
77677   }
77678   {
77679     try {
77680       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
77681     } catch (std::out_of_range& e) {
77682       {
77683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77684       };
77685     } catch (std::exception& e) {
77686       {
77687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77688       };
77689     } catch (Dali::DaliException e) {
77690       {
77691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77692       };
77693     } catch (...) {
77694       {
77695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77696       };
77697     }
77698   }
77699
77700   jresult = result;
77701   return jresult;
77702 }
77703
77704
77705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
77706   void * jresult ;
77707   Dali::Toolkit::DefaultRuler *result = 0 ;
77708
77709   {
77710     try {
77711       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
77712     } catch (std::out_of_range& e) {
77713       {
77714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77715       };
77716     } catch (std::exception& e) {
77717       {
77718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77719       };
77720     } catch (Dali::DaliException e) {
77721       {
77722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77723       };
77724     } catch (...) {
77725       {
77726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77727       };
77728     }
77729   }
77730
77731   jresult = (void *)result;
77732   return jresult;
77733 }
77734
77735
77736 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
77737   float jresult ;
77738   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77739   float arg2 ;
77740   float arg3 ;
77741   float result;
77742
77743   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77744   arg2 = (float)jarg2;
77745   arg3 = (float)jarg3;
77746   {
77747     try {
77748       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
77749     } catch (std::out_of_range& e) {
77750       {
77751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77752       };
77753     } catch (std::exception& e) {
77754       {
77755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77756       };
77757     } catch (Dali::DaliException e) {
77758       {
77759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77760       };
77761     } catch (...) {
77762       {
77763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77764       };
77765     }
77766   }
77767
77768   jresult = result;
77769   return jresult;
77770 }
77771
77772
77773 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77774   float jresult ;
77775   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77776   unsigned int arg2 ;
77777   unsigned int *arg3 = 0 ;
77778   bool arg4 ;
77779   float result;
77780
77781   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77782   arg2 = (unsigned int)jarg2;
77783   arg3 = (unsigned int *)jarg3;
77784   arg4 = jarg4 ? true : false;
77785   {
77786     try {
77787       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77788     } catch (std::out_of_range& e) {
77789       {
77790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77791       };
77792     } catch (std::exception& e) {
77793       {
77794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77795       };
77796     } catch (Dali::DaliException e) {
77797       {
77798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77799       };
77800     } catch (...) {
77801       {
77802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77803       };
77804     }
77805   }
77806
77807   jresult = result;
77808   return jresult;
77809 }
77810
77811
77812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77813   unsigned int jresult ;
77814   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77815   float arg2 ;
77816   bool arg3 ;
77817   unsigned int result;
77818
77819   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77820   arg2 = (float)jarg2;
77821   arg3 = jarg3 ? true : false;
77822   {
77823     try {
77824       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
77825     } catch (std::out_of_range& e) {
77826       {
77827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77828       };
77829     } catch (std::exception& e) {
77830       {
77831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77832       };
77833     } catch (Dali::DaliException e) {
77834       {
77835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77836       };
77837     } catch (...) {
77838       {
77839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77840       };
77841     }
77842   }
77843
77844   jresult = result;
77845   return jresult;
77846 }
77847
77848
77849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
77850   unsigned int jresult ;
77851   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77852   unsigned int result;
77853
77854   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77855   {
77856     try {
77857       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
77858     } catch (std::out_of_range& e) {
77859       {
77860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77861       };
77862     } catch (std::exception& e) {
77863       {
77864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77865       };
77866     } catch (Dali::DaliException e) {
77867       {
77868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77869       };
77870     } catch (...) {
77871       {
77872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77873       };
77874     }
77875   }
77876
77877   jresult = result;
77878   return jresult;
77879 }
77880
77881
77882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
77883   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77884
77885   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77886   {
77887     try {
77888       delete arg1;
77889     } catch (std::out_of_range& e) {
77890       {
77891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77892       };
77893     } catch (std::exception& e) {
77894       {
77895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77896       };
77897     } catch (Dali::DaliException e) {
77898       {
77899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77900       };
77901     } catch (...) {
77902       {
77903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77904       };
77905     }
77906   }
77907
77908 }
77909
77910
77911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
77912   void * jresult ;
77913   float arg1 ;
77914   Dali::Toolkit::FixedRuler *result = 0 ;
77915
77916   arg1 = (float)jarg1;
77917   {
77918     try {
77919       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
77920     } catch (std::out_of_range& e) {
77921       {
77922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77923       };
77924     } catch (std::exception& e) {
77925       {
77926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77927       };
77928     } catch (Dali::DaliException e) {
77929       {
77930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77931       };
77932     } catch (...) {
77933       {
77934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77935       };
77936     }
77937   }
77938
77939   jresult = (void *)result;
77940   return jresult;
77941 }
77942
77943
77944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
77945   void * jresult ;
77946   Dali::Toolkit::FixedRuler *result = 0 ;
77947
77948   {
77949     try {
77950       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
77951     } catch (std::out_of_range& e) {
77952       {
77953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77954       };
77955     } catch (std::exception& e) {
77956       {
77957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77958       };
77959     } catch (Dali::DaliException e) {
77960       {
77961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77962       };
77963     } catch (...) {
77964       {
77965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77966       };
77967     }
77968   }
77969
77970   jresult = (void *)result;
77971   return jresult;
77972 }
77973
77974
77975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
77976   float jresult ;
77977   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
77978   float arg2 ;
77979   float arg3 ;
77980   float result;
77981
77982   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
77983   arg2 = (float)jarg2;
77984   arg3 = (float)jarg3;
77985   {
77986     try {
77987       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
77988     } catch (std::out_of_range& e) {
77989       {
77990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77991       };
77992     } catch (std::exception& e) {
77993       {
77994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77995       };
77996     } catch (Dali::DaliException e) {
77997       {
77998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77999       };
78000     } catch (...) {
78001       {
78002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78003       };
78004     }
78005   }
78006
78007   jresult = result;
78008   return jresult;
78009 }
78010
78011
78012 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78013   float jresult ;
78014   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78015   unsigned int arg2 ;
78016   unsigned int *arg3 = 0 ;
78017   bool arg4 ;
78018   float result;
78019
78020   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78021   arg2 = (unsigned int)jarg2;
78022   arg3 = (unsigned int *)jarg3;
78023   arg4 = jarg4 ? true : false;
78024   {
78025     try {
78026       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78027     } catch (std::out_of_range& e) {
78028       {
78029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78030       };
78031     } catch (std::exception& e) {
78032       {
78033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78034       };
78035     } catch (Dali::DaliException e) {
78036       {
78037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78038       };
78039     } catch (...) {
78040       {
78041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78042       };
78043     }
78044   }
78045
78046   jresult = result;
78047   return jresult;
78048 }
78049
78050
78051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78052   unsigned int jresult ;
78053   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78054   float arg2 ;
78055   bool arg3 ;
78056   unsigned int result;
78057
78058   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78059   arg2 = (float)jarg2;
78060   arg3 = jarg3 ? true : false;
78061   {
78062     try {
78063       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78064     } catch (std::out_of_range& e) {
78065       {
78066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78067       };
78068     } catch (std::exception& e) {
78069       {
78070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78071       };
78072     } catch (Dali::DaliException e) {
78073       {
78074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78075       };
78076     } catch (...) {
78077       {
78078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78079       };
78080     }
78081   }
78082
78083   jresult = result;
78084   return jresult;
78085 }
78086
78087
78088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
78089   unsigned int jresult ;
78090   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78091   unsigned int result;
78092
78093   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78094   {
78095     try {
78096       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
78097     } catch (std::out_of_range& e) {
78098       {
78099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78100       };
78101     } catch (std::exception& e) {
78102       {
78103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78104       };
78105     } catch (Dali::DaliException e) {
78106       {
78107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78108       };
78109     } catch (...) {
78110       {
78111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78112       };
78113     }
78114   }
78115
78116   jresult = result;
78117   return jresult;
78118 }
78119
78120
78121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
78122   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78123
78124   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78125   {
78126     try {
78127       delete arg1;
78128     } catch (std::out_of_range& e) {
78129       {
78130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78131       };
78132     } catch (std::exception& e) {
78133       {
78134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78135       };
78136     } catch (Dali::DaliException e) {
78137       {
78138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78139       };
78140     } catch (...) {
78141       {
78142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78143       };
78144     }
78145   }
78146
78147 }
78148
78149
78150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
78151   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78152   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
78153
78154   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78155   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
78156   if (arg1) (arg1)->scale = *arg2;
78157 }
78158
78159
78160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
78161   void * jresult ;
78162   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78163   Dali::Toolkit::ClampState2D *result = 0 ;
78164
78165   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78166   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
78167   jresult = (void *)result;
78168   return jresult;
78169 }
78170
78171
78172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
78173   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78174   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
78175
78176   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78177   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
78178   if (arg1) (arg1)->position = *arg2;
78179 }
78180
78181
78182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
78183   void * jresult ;
78184   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78185   Dali::Toolkit::ClampState2D *result = 0 ;
78186
78187   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78188   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
78189   jresult = (void *)result;
78190   return jresult;
78191 }
78192
78193
78194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
78195   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78196   Dali::Toolkit::ClampState arg2 ;
78197
78198   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78199   arg2 = (Dali::Toolkit::ClampState)jarg2;
78200   if (arg1) (arg1)->rotation = arg2;
78201 }
78202
78203
78204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
78205   int jresult ;
78206   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78207   Dali::Toolkit::ClampState result;
78208
78209   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78210   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
78211   jresult = (int)result;
78212   return jresult;
78213 }
78214
78215
78216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
78217   void * jresult ;
78218   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
78219
78220   {
78221     try {
78222       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
78223     } catch (std::out_of_range& e) {
78224       {
78225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78226       };
78227     } catch (std::exception& e) {
78228       {
78229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78230       };
78231     } catch (Dali::DaliException e) {
78232       {
78233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78234       };
78235     } catch (...) {
78236       {
78237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78238       };
78239     }
78240   }
78241
78242   jresult = (void *)result;
78243   return jresult;
78244 }
78245
78246
78247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
78248   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78249
78250   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78251   {
78252     try {
78253       delete arg1;
78254     } catch (std::out_of_range& e) {
78255       {
78256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78257       };
78258     } catch (std::exception& e) {
78259       {
78260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78261       };
78262     } catch (Dali::DaliException e) {
78263       {
78264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78265       };
78266     } catch (...) {
78267       {
78268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78269       };
78270     }
78271   }
78272
78273 }
78274
78275
78276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
78277   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78278   Dali::Toolkit::SnapType arg2 ;
78279
78280   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78281   arg2 = (Dali::Toolkit::SnapType)jarg2;
78282   if (arg1) (arg1)->type = arg2;
78283 }
78284
78285
78286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
78287   int jresult ;
78288   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78289   Dali::Toolkit::SnapType result;
78290
78291   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78292   result = (Dali::Toolkit::SnapType) ((arg1)->type);
78293   jresult = (int)result;
78294   return jresult;
78295 }
78296
78297
78298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
78299   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78300   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
78301
78302   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78303   arg2 = (Dali::Vector2 *)jarg2;
78304   if (arg1) (arg1)->position = *arg2;
78305 }
78306
78307
78308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
78309   void * jresult ;
78310   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78311   Dali::Vector2 *result = 0 ;
78312
78313   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78314   result = (Dali::Vector2 *)& ((arg1)->position);
78315   jresult = (void *)result;
78316   return jresult;
78317 }
78318
78319
78320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
78321   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78322   float arg2 ;
78323
78324   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78325   arg2 = (float)jarg2;
78326   if (arg1) (arg1)->duration = arg2;
78327 }
78328
78329
78330 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
78331   float jresult ;
78332   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78333   float result;
78334
78335   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78336   result = (float) ((arg1)->duration);
78337   jresult = result;
78338   return jresult;
78339 }
78340
78341
78342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
78343   void * jresult ;
78344   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
78345
78346   {
78347     try {
78348       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
78349     } catch (std::out_of_range& e) {
78350       {
78351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78352       };
78353     } catch (std::exception& e) {
78354       {
78355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78356       };
78357     } catch (Dali::DaliException e) {
78358       {
78359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78360       };
78361     } catch (...) {
78362       {
78363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78364       };
78365     }
78366   }
78367
78368   jresult = (void *)result;
78369   return jresult;
78370 }
78371
78372
78373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
78374   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78375
78376   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78377   {
78378     try {
78379       delete arg1;
78380     } catch (std::out_of_range& e) {
78381       {
78382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78383       };
78384     } catch (std::exception& e) {
78385       {
78386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78387       };
78388     } catch (Dali::DaliException e) {
78389       {
78390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78391       };
78392     } catch (...) {
78393       {
78394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78395       };
78396     }
78397   }
78398
78399 }
78400
78401
78402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
78403   int jresult ;
78404   int result;
78405
78406   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
78407   jresult = (int)result;
78408   return jresult;
78409 }
78410
78411
78412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
78413   int jresult ;
78414   int result;
78415
78416   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
78417   jresult = (int)result;
78418   return jresult;
78419 }
78420
78421
78422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
78423   int jresult ;
78424   int result;
78425
78426   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
78427   jresult = (int)result;
78428   return jresult;
78429 }
78430
78431
78432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
78433   int jresult ;
78434   int result;
78435
78436   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
78437   jresult = (int)result;
78438   return jresult;
78439 }
78440
78441
78442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
78443   int jresult ;
78444   int result;
78445
78446   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
78447   jresult = (int)result;
78448   return jresult;
78449 }
78450
78451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
78452   int jresult ;
78453   int result;
78454
78455   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
78456   jresult = (int)result;
78457   return jresult;
78458 }
78459
78460
78461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
78462   int jresult ;
78463   int result;
78464
78465   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
78466   jresult = (int)result;
78467   return jresult;
78468 }
78469
78470
78471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
78472   int jresult ;
78473   int result;
78474
78475   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
78476   jresult = (int)result;
78477   return jresult;
78478 }
78479
78480
78481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
78482   int jresult ;
78483   int result;
78484
78485   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
78486   jresult = (int)result;
78487   return jresult;
78488 }
78489
78490
78491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
78492   int jresult ;
78493   int result;
78494
78495   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
78496   jresult = (int)result;
78497   return jresult;
78498 }
78499
78500
78501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
78502   int jresult ;
78503   int result;
78504
78505   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
78506   jresult = (int)result;
78507   return jresult;
78508 }
78509
78510
78511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
78512   int jresult ;
78513   int result;
78514
78515   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
78516   jresult = (int)result;
78517   return jresult;
78518 }
78519
78520
78521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
78522   int jresult ;
78523   int result;
78524
78525   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
78526   jresult = (int)result;
78527   return jresult;
78528 }
78529
78530
78531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
78532   int jresult ;
78533   int result;
78534
78535   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
78536   jresult = (int)result;
78537   return jresult;
78538 }
78539
78540
78541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
78542   int jresult ;
78543   int result;
78544
78545   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
78546   jresult = (int)result;
78547   return jresult;
78548 }
78549
78550
78551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
78552   int jresult ;
78553   int result;
78554
78555   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
78556   jresult = (int)result;
78557   return jresult;
78558 }
78559
78560
78561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
78562   int jresult ;
78563   int result;
78564
78565   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
78566   jresult = (int)result;
78567   return jresult;
78568 }
78569
78570
78571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
78572   int jresult ;
78573   int result;
78574
78575   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
78576   jresult = (int)result;
78577   return jresult;
78578 }
78579
78580
78581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
78582   int jresult ;
78583   int result;
78584
78585   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
78586   jresult = (int)result;
78587   return jresult;
78588 }
78589
78590
78591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
78592   int jresult ;
78593   int result;
78594
78595   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
78596   jresult = (int)result;
78597   return jresult;
78598 }
78599
78600
78601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
78602   int jresult ;
78603   int result;
78604
78605   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
78606   jresult = (int)result;
78607   return jresult;
78608 }
78609
78610
78611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
78612   int jresult ;
78613   int result;
78614
78615   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
78616   jresult = (int)result;
78617   return jresult;
78618 }
78619
78620
78621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
78622   int jresult ;
78623   int result;
78624
78625   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
78626   jresult = (int)result;
78627   return jresult;
78628 }
78629
78630
78631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
78632   int jresult ;
78633   int result;
78634
78635   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
78636   jresult = (int)result;
78637   return jresult;
78638 }
78639
78640
78641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
78642   int jresult ;
78643   int result;
78644
78645   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
78646   jresult = (int)result;
78647   return jresult;
78648 }
78649
78650
78651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
78652   int jresult ;
78653   int result;
78654
78655   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
78656   jresult = (int)result;
78657   return jresult;
78658 }
78659
78660
78661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
78662   void * jresult ;
78663   Dali::Toolkit::ScrollView::Property *result = 0 ;
78664
78665   {
78666     try {
78667       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
78668     } catch (std::out_of_range& e) {
78669       {
78670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78671       };
78672     } catch (std::exception& e) {
78673       {
78674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78675       };
78676     } catch (Dali::DaliException e) {
78677       {
78678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78679       };
78680     } catch (...) {
78681       {
78682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78683       };
78684     }
78685   }
78686
78687   jresult = (void *)result;
78688   return jresult;
78689 }
78690
78691
78692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
78693   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
78694
78695   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
78696   {
78697     try {
78698       delete arg1;
78699     } catch (std::out_of_range& e) {
78700       {
78701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78702       };
78703     } catch (std::exception& e) {
78704       {
78705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78706       };
78707     } catch (Dali::DaliException e) {
78708       {
78709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78710       };
78711     } catch (...) {
78712       {
78713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78714       };
78715     }
78716   }
78717
78718 }
78719
78720
78721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
78722   void * jresult ;
78723   Dali::Toolkit::ScrollView *result = 0 ;
78724
78725   {
78726     try {
78727       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
78728     } catch (std::out_of_range& e) {
78729       {
78730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78731       };
78732     } catch (std::exception& e) {
78733       {
78734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78735       };
78736     } catch (Dali::DaliException e) {
78737       {
78738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78739       };
78740     } catch (...) {
78741       {
78742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78743       };
78744     }
78745   }
78746
78747   jresult = (void *)result;
78748   return jresult;
78749 }
78750
78751
78752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
78753   void * jresult ;
78754   Dali::Toolkit::ScrollView *arg1 = 0 ;
78755   Dali::Toolkit::ScrollView *result = 0 ;
78756
78757   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78758   if (!arg1) {
78759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78760     return 0;
78761   }
78762   {
78763     try {
78764       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
78765     } catch (std::out_of_range& e) {
78766       {
78767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78768       };
78769     } catch (std::exception& e) {
78770       {
78771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78772       };
78773     } catch (Dali::DaliException e) {
78774       {
78775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78776       };
78777     } catch (...) {
78778       {
78779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78780       };
78781     }
78782   }
78783
78784   jresult = (void *)result;
78785   return jresult;
78786 }
78787
78788
78789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
78790   void * jresult ;
78791   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78792   Dali::Toolkit::ScrollView *arg2 = 0 ;
78793   Dali::Toolkit::ScrollView *result = 0 ;
78794
78795   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78796   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
78797   if (!arg2) {
78798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78799     return 0;
78800   }
78801   {
78802     try {
78803       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
78804     } catch (std::out_of_range& e) {
78805       {
78806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78807       };
78808     } catch (std::exception& e) {
78809       {
78810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78811       };
78812     } catch (Dali::DaliException e) {
78813       {
78814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78815       };
78816     } catch (...) {
78817       {
78818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78819       };
78820     }
78821   }
78822
78823   jresult = (void *)result;
78824   return jresult;
78825 }
78826
78827
78828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
78829   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78830
78831   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78832   {
78833     try {
78834       delete arg1;
78835     } catch (std::out_of_range& e) {
78836       {
78837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78838       };
78839     } catch (std::exception& e) {
78840       {
78841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78842       };
78843     } catch (Dali::DaliException e) {
78844       {
78845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78846       };
78847     } catch (...) {
78848       {
78849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78850       };
78851     }
78852   }
78853
78854 }
78855
78856
78857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
78858   void * jresult ;
78859   Dali::Toolkit::ScrollView result;
78860
78861   {
78862     try {
78863       result = Dali::Toolkit::ScrollView::New();
78864     } catch (std::out_of_range& e) {
78865       {
78866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78867       };
78868     } catch (std::exception& e) {
78869       {
78870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78871       };
78872     } catch (Dali::DaliException e) {
78873       {
78874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78875       };
78876     } catch (...) {
78877       {
78878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78879       };
78880     }
78881   }
78882
78883   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
78884   return jresult;
78885 }
78886
78887
78888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
78889   void * jresult ;
78890   Dali::BaseHandle arg1 ;
78891   Dali::BaseHandle *argp1 ;
78892   Dali::Toolkit::ScrollView result;
78893
78894   argp1 = (Dali::BaseHandle *)jarg1;
78895   if (!argp1) {
78896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78897     return 0;
78898   }
78899   arg1 = *argp1;
78900   {
78901     try {
78902       result = Dali::Toolkit::ScrollView::DownCast(arg1);
78903     } catch (std::out_of_range& e) {
78904       {
78905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78906       };
78907     } catch (std::exception& e) {
78908       {
78909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78910       };
78911     } catch (Dali::DaliException e) {
78912       {
78913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78914       };
78915     } catch (...) {
78916       {
78917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78918       };
78919     }
78920   }
78921
78922   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
78923   return jresult;
78924 }
78925
78926
78927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
78928   void * jresult ;
78929   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78930   Dali::AlphaFunction result;
78931
78932   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78933   {
78934     try {
78935       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
78936     } catch (std::out_of_range& e) {
78937       {
78938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78939       };
78940     } catch (std::exception& e) {
78941       {
78942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78943       };
78944     } catch (Dali::DaliException e) {
78945       {
78946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78947       };
78948     } catch (...) {
78949       {
78950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78951       };
78952     }
78953   }
78954
78955   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
78956   return jresult;
78957 }
78958
78959
78960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
78961   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78962   Dali::AlphaFunction arg2 ;
78963   Dali::AlphaFunction *argp2 ;
78964
78965   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78966   argp2 = (Dali::AlphaFunction *)jarg2;
78967   if (!argp2) {
78968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
78969     return ;
78970   }
78971   arg2 = *argp2;
78972   {
78973     try {
78974       (arg1)->SetScrollSnapAlphaFunction(arg2);
78975     } catch (std::out_of_range& e) {
78976       {
78977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78978       };
78979     } catch (std::exception& e) {
78980       {
78981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78982       };
78983     } catch (Dali::DaliException e) {
78984       {
78985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78986       };
78987     } catch (...) {
78988       {
78989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78990       };
78991     }
78992   }
78993
78994 }
78995
78996
78997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
78998   void * jresult ;
78999   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79000   Dali::AlphaFunction result;
79001
79002   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79003   {
79004     try {
79005       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
79006     } catch (std::out_of_range& e) {
79007       {
79008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79009       };
79010     } catch (std::exception& e) {
79011       {
79012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79013       };
79014     } catch (Dali::DaliException e) {
79015       {
79016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79017       };
79018     } catch (...) {
79019       {
79020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79021       };
79022     }
79023   }
79024
79025   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79026   return jresult;
79027 }
79028
79029
79030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
79031   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79032   Dali::AlphaFunction arg2 ;
79033   Dali::AlphaFunction *argp2 ;
79034
79035   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79036   argp2 = (Dali::AlphaFunction *)jarg2;
79037   if (!argp2) {
79038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79039     return ;
79040   }
79041   arg2 = *argp2;
79042   {
79043     try {
79044       (arg1)->SetScrollFlickAlphaFunction(arg2);
79045     } catch (std::out_of_range& e) {
79046       {
79047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79048       };
79049     } catch (std::exception& e) {
79050       {
79051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79052       };
79053     } catch (Dali::DaliException e) {
79054       {
79055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79056       };
79057     } catch (...) {
79058       {
79059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79060       };
79061     }
79062   }
79063
79064 }
79065
79066
79067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
79068   float jresult ;
79069   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79070   float result;
79071
79072   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79073   {
79074     try {
79075       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
79076     } catch (std::out_of_range& e) {
79077       {
79078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79079       };
79080     } catch (std::exception& e) {
79081       {
79082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79083       };
79084     } catch (Dali::DaliException e) {
79085       {
79086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79087       };
79088     } catch (...) {
79089       {
79090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79091       };
79092     }
79093   }
79094
79095   jresult = result;
79096   return jresult;
79097 }
79098
79099
79100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
79101   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79102   float arg2 ;
79103
79104   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79105   arg2 = (float)jarg2;
79106   {
79107     try {
79108       (arg1)->SetScrollSnapDuration(arg2);
79109     } catch (std::out_of_range& e) {
79110       {
79111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79112       };
79113     } catch (std::exception& e) {
79114       {
79115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79116       };
79117     } catch (Dali::DaliException e) {
79118       {
79119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79120       };
79121     } catch (...) {
79122       {
79123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79124       };
79125     }
79126   }
79127
79128 }
79129
79130
79131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
79132   float jresult ;
79133   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79134   float result;
79135
79136   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79137   {
79138     try {
79139       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
79140     } catch (std::out_of_range& e) {
79141       {
79142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79143       };
79144     } catch (std::exception& e) {
79145       {
79146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79147       };
79148     } catch (Dali::DaliException e) {
79149       {
79150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79151       };
79152     } catch (...) {
79153       {
79154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79155       };
79156     }
79157   }
79158
79159   jresult = result;
79160   return jresult;
79161 }
79162
79163
79164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
79165   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79166   float arg2 ;
79167
79168   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79169   arg2 = (float)jarg2;
79170   {
79171     try {
79172       (arg1)->SetScrollFlickDuration(arg2);
79173     } catch (std::out_of_range& e) {
79174       {
79175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79176       };
79177     } catch (std::exception& e) {
79178       {
79179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79180       };
79181     } catch (Dali::DaliException e) {
79182       {
79183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79184       };
79185     } catch (...) {
79186       {
79187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79188       };
79189     }
79190   }
79191
79192 }
79193
79194
79195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
79196   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79197   Dali::Toolkit::RulerPtr arg2 ;
79198   Dali::Toolkit::RulerPtr *argp2 ;
79199
79200   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79201   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
79202   if (!argp2) {
79203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
79204     return ;
79205   }
79206   arg2 = *argp2;
79207   {
79208     try {
79209       (arg1)->SetRulerX(arg2);
79210     } catch (std::out_of_range& e) {
79211       {
79212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79213       };
79214     } catch (std::exception& e) {
79215       {
79216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79217       };
79218     } catch (Dali::DaliException e) {
79219       {
79220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79221       };
79222     } catch (...) {
79223       {
79224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79225       };
79226     }
79227   }
79228
79229 }
79230
79231
79232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
79233   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79234   Dali::Toolkit::RulerPtr arg2 ;
79235   Dali::Toolkit::RulerPtr *argp2 ;
79236
79237   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79238   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
79239   if (!argp2) {
79240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
79241     return ;
79242   }
79243   arg2 = *argp2;
79244   {
79245     try {
79246       (arg1)->SetRulerY(arg2);
79247     } catch (std::out_of_range& e) {
79248       {
79249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79250       };
79251     } catch (std::exception& e) {
79252       {
79253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79254       };
79255     } catch (Dali::DaliException e) {
79256       {
79257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79258       };
79259     } catch (...) {
79260       {
79261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79262       };
79263     }
79264   }
79265
79266 }
79267
79268
79269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
79270   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79271   bool arg2 ;
79272
79273   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79274   arg2 = jarg2 ? true : false;
79275   {
79276     try {
79277       (arg1)->SetScrollSensitive(arg2);
79278     } catch (std::out_of_range& e) {
79279       {
79280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79281       };
79282     } catch (std::exception& e) {
79283       {
79284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79285       };
79286     } catch (Dali::DaliException e) {
79287       {
79288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79289       };
79290     } catch (...) {
79291       {
79292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79293       };
79294     }
79295   }
79296
79297 }
79298
79299
79300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
79301   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79302   float arg2 ;
79303   float arg3 ;
79304
79305   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79306   arg2 = (float)jarg2;
79307   arg3 = (float)jarg3;
79308   {
79309     try {
79310       (arg1)->SetMaxOvershoot(arg2,arg3);
79311     } catch (std::out_of_range& e) {
79312       {
79313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79314       };
79315     } catch (std::exception& e) {
79316       {
79317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79318       };
79319     } catch (Dali::DaliException e) {
79320       {
79321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79322       };
79323     } catch (...) {
79324       {
79325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79326       };
79327     }
79328   }
79329
79330 }
79331
79332
79333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
79334   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79335   Dali::AlphaFunction arg2 ;
79336   Dali::AlphaFunction *argp2 ;
79337
79338   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79339   argp2 = (Dali::AlphaFunction *)jarg2;
79340   if (!argp2) {
79341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79342     return ;
79343   }
79344   arg2 = *argp2;
79345   {
79346     try {
79347       (arg1)->SetSnapOvershootAlphaFunction(arg2);
79348     } catch (std::out_of_range& e) {
79349       {
79350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79351       };
79352     } catch (std::exception& e) {
79353       {
79354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79355       };
79356     } catch (Dali::DaliException e) {
79357       {
79358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79359       };
79360     } catch (...) {
79361       {
79362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79363       };
79364     }
79365   }
79366
79367 }
79368
79369
79370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
79371   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79372   float arg2 ;
79373
79374   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79375   arg2 = (float)jarg2;
79376   {
79377     try {
79378       (arg1)->SetSnapOvershootDuration(arg2);
79379     } catch (std::out_of_range& e) {
79380       {
79381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79382       };
79383     } catch (std::exception& e) {
79384       {
79385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79386       };
79387     } catch (Dali::DaliException e) {
79388       {
79389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79390       };
79391     } catch (...) {
79392       {
79393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79394       };
79395     }
79396   }
79397
79398 }
79399
79400
79401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
79402   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79403   bool arg2 ;
79404
79405   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79406   arg2 = jarg2 ? true : false;
79407   {
79408     try {
79409       (arg1)->SetActorAutoSnap(arg2);
79410     } catch (std::out_of_range& e) {
79411       {
79412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79413       };
79414     } catch (std::exception& e) {
79415       {
79416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79417       };
79418     } catch (Dali::DaliException e) {
79419       {
79420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79421       };
79422     } catch (...) {
79423       {
79424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79425       };
79426     }
79427   }
79428
79429 }
79430
79431
79432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
79433   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79434   bool arg2 ;
79435
79436   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79437   arg2 = jarg2 ? true : false;
79438   {
79439     try {
79440       (arg1)->SetWrapMode(arg2);
79441     } catch (std::out_of_range& e) {
79442       {
79443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79444       };
79445     } catch (std::exception& e) {
79446       {
79447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79448       };
79449     } catch (Dali::DaliException e) {
79450       {
79451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79452       };
79453     } catch (...) {
79454       {
79455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79456       };
79457     }
79458   }
79459
79460 }
79461
79462
79463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
79464   int jresult ;
79465   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79466   int result;
79467
79468   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79469   {
79470     try {
79471       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
79472     } catch (std::out_of_range& e) {
79473       {
79474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79475       };
79476     } catch (std::exception& e) {
79477       {
79478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79479       };
79480     } catch (Dali::DaliException e) {
79481       {
79482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79483       };
79484     } catch (...) {
79485       {
79486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79487       };
79488     }
79489   }
79490
79491   jresult = result;
79492   return jresult;
79493 }
79494
79495
79496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
79497   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79498   int arg2 ;
79499
79500   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79501   arg2 = (int)jarg2;
79502   {
79503     try {
79504       (arg1)->SetScrollUpdateDistance(arg2);
79505     } catch (std::out_of_range& e) {
79506       {
79507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79508       };
79509     } catch (std::exception& e) {
79510       {
79511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79512       };
79513     } catch (Dali::DaliException e) {
79514       {
79515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79516       };
79517     } catch (...) {
79518       {
79519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79520       };
79521     }
79522   }
79523
79524 }
79525
79526
79527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
79528   unsigned int jresult ;
79529   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79530   bool result;
79531
79532   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79533   {
79534     try {
79535       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
79536     } catch (std::out_of_range& e) {
79537       {
79538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79539       };
79540     } catch (std::exception& e) {
79541       {
79542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79543       };
79544     } catch (Dali::DaliException e) {
79545       {
79546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79547       };
79548     } catch (...) {
79549       {
79550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79551       };
79552     }
79553   }
79554
79555   jresult = result;
79556   return jresult;
79557 }
79558
79559
79560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
79561   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79562   bool arg2 ;
79563
79564   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79565   arg2 = jarg2 ? true : false;
79566   {
79567     try {
79568       (arg1)->SetAxisAutoLock(arg2);
79569     } catch (std::out_of_range& e) {
79570       {
79571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79572       };
79573     } catch (std::exception& e) {
79574       {
79575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79576       };
79577     } catch (Dali::DaliException e) {
79578       {
79579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79580       };
79581     } catch (...) {
79582       {
79583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79584       };
79585     }
79586   }
79587
79588 }
79589
79590
79591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
79592   float jresult ;
79593   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79594   float result;
79595
79596   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79597   {
79598     try {
79599       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
79600     } catch (std::out_of_range& e) {
79601       {
79602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79603       };
79604     } catch (std::exception& e) {
79605       {
79606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79607       };
79608     } catch (Dali::DaliException e) {
79609       {
79610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79611       };
79612     } catch (...) {
79613       {
79614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79615       };
79616     }
79617   }
79618
79619   jresult = result;
79620   return jresult;
79621 }
79622
79623
79624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
79625   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79626   float arg2 ;
79627
79628   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79629   arg2 = (float)jarg2;
79630   {
79631     try {
79632       (arg1)->SetAxisAutoLockGradient(arg2);
79633     } catch (std::out_of_range& e) {
79634       {
79635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79636       };
79637     } catch (std::exception& e) {
79638       {
79639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79640       };
79641     } catch (Dali::DaliException e) {
79642       {
79643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79644       };
79645     } catch (...) {
79646       {
79647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79648       };
79649     }
79650   }
79651
79652 }
79653
79654
79655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
79656   float jresult ;
79657   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79658   float result;
79659
79660   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79661   {
79662     try {
79663       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
79664     } catch (std::out_of_range& e) {
79665       {
79666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79667       };
79668     } catch (std::exception& e) {
79669       {
79670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79671       };
79672     } catch (Dali::DaliException e) {
79673       {
79674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79675       };
79676     } catch (...) {
79677       {
79678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79679       };
79680     }
79681   }
79682
79683   jresult = result;
79684   return jresult;
79685 }
79686
79687
79688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
79689   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79690   float arg2 ;
79691
79692   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79693   arg2 = (float)jarg2;
79694   {
79695     try {
79696       (arg1)->SetFrictionCoefficient(arg2);
79697     } catch (std::out_of_range& e) {
79698       {
79699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79700       };
79701     } catch (std::exception& e) {
79702       {
79703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79704       };
79705     } catch (Dali::DaliException e) {
79706       {
79707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79708       };
79709     } catch (...) {
79710       {
79711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79712       };
79713     }
79714   }
79715
79716 }
79717
79718
79719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
79720   float jresult ;
79721   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79722   float result;
79723
79724   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79725   {
79726     try {
79727       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
79728     } catch (std::out_of_range& e) {
79729       {
79730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79731       };
79732     } catch (std::exception& e) {
79733       {
79734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79735       };
79736     } catch (Dali::DaliException e) {
79737       {
79738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79739       };
79740     } catch (...) {
79741       {
79742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79743       };
79744     }
79745   }
79746
79747   jresult = result;
79748   return jresult;
79749 }
79750
79751
79752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
79753   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79754   float arg2 ;
79755
79756   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79757   arg2 = (float)jarg2;
79758   {
79759     try {
79760       (arg1)->SetFlickSpeedCoefficient(arg2);
79761     } catch (std::out_of_range& e) {
79762       {
79763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79764       };
79765     } catch (std::exception& e) {
79766       {
79767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79768       };
79769     } catch (Dali::DaliException e) {
79770       {
79771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79772       };
79773     } catch (...) {
79774       {
79775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79776       };
79777     }
79778   }
79779
79780 }
79781
79782
79783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
79784   void * jresult ;
79785   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79786   Dali::Vector2 result;
79787
79788   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79789   {
79790     try {
79791       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
79792     } catch (std::out_of_range& e) {
79793       {
79794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79795       };
79796     } catch (std::exception& e) {
79797       {
79798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79799       };
79800     } catch (Dali::DaliException e) {
79801       {
79802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79803       };
79804     } catch (...) {
79805       {
79806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79807       };
79808     }
79809   }
79810
79811   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79812   return jresult;
79813 }
79814
79815
79816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
79817   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79818   Dali::Vector2 *arg2 = 0 ;
79819
79820   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79821   arg2 = (Dali::Vector2 *)jarg2;
79822   if (!arg2) {
79823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
79824     return ;
79825   }
79826   {
79827     try {
79828       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
79829     } catch (std::out_of_range& e) {
79830       {
79831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79832       };
79833     } catch (std::exception& e) {
79834       {
79835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79836       };
79837     } catch (Dali::DaliException e) {
79838       {
79839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79840       };
79841     } catch (...) {
79842       {
79843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79844       };
79845     }
79846   }
79847
79848 }
79849
79850
79851 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
79852   float jresult ;
79853   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79854   float result;
79855
79856   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79857   {
79858     try {
79859       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
79860     } catch (std::out_of_range& e) {
79861       {
79862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79863       };
79864     } catch (std::exception& e) {
79865       {
79866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79867       };
79868     } catch (Dali::DaliException e) {
79869       {
79870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79871       };
79872     } catch (...) {
79873       {
79874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79875       };
79876     }
79877   }
79878
79879   jresult = result;
79880   return jresult;
79881 }
79882
79883
79884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
79885   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79886   float arg2 ;
79887
79888   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79889   arg2 = (float)jarg2;
79890   {
79891     try {
79892       (arg1)->SetMinimumSpeedForFlick(arg2);
79893     } catch (std::out_of_range& e) {
79894       {
79895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79896       };
79897     } catch (std::exception& e) {
79898       {
79899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79900       };
79901     } catch (Dali::DaliException e) {
79902       {
79903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79904       };
79905     } catch (...) {
79906       {
79907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79908       };
79909     }
79910   }
79911
79912 }
79913
79914
79915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
79916   float jresult ;
79917   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79918   float result;
79919
79920   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79921   {
79922     try {
79923       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
79924     } catch (std::out_of_range& e) {
79925       {
79926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79927       };
79928     } catch (std::exception& e) {
79929       {
79930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79931       };
79932     } catch (Dali::DaliException e) {
79933       {
79934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79935       };
79936     } catch (...) {
79937       {
79938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79939       };
79940     }
79941   }
79942
79943   jresult = result;
79944   return jresult;
79945 }
79946
79947
79948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
79949   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79950   float arg2 ;
79951
79952   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79953   arg2 = (float)jarg2;
79954   {
79955     try {
79956       (arg1)->SetMaxFlickSpeed(arg2);
79957     } catch (std::out_of_range& e) {
79958       {
79959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79960       };
79961     } catch (std::exception& e) {
79962       {
79963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79964       };
79965     } catch (Dali::DaliException e) {
79966       {
79967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79968       };
79969     } catch (...) {
79970       {
79971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79972       };
79973     }
79974   }
79975
79976 }
79977
79978
79979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
79980   void * jresult ;
79981   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79982   Dali::Vector2 result;
79983
79984   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79985   {
79986     try {
79987       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
79988     } catch (std::out_of_range& e) {
79989       {
79990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79991       };
79992     } catch (std::exception& e) {
79993       {
79994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79995       };
79996     } catch (Dali::DaliException e) {
79997       {
79998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79999       };
80000     } catch (...) {
80001       {
80002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80003       };
80004     }
80005   }
80006
80007   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80008   return jresult;
80009 }
80010
80011
80012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
80013   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80014   Dali::Vector2 arg2 ;
80015   Dali::Vector2 *argp2 ;
80016
80017   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80018   argp2 = (Dali::Vector2 *)jarg2;
80019   if (!argp2) {
80020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
80021     return ;
80022   }
80023   arg2 = *argp2;
80024   {
80025     try {
80026       (arg1)->SetWheelScrollDistanceStep(arg2);
80027     } catch (std::out_of_range& e) {
80028       {
80029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80030       };
80031     } catch (std::exception& e) {
80032       {
80033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80034       };
80035     } catch (Dali::DaliException e) {
80036       {
80037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80038       };
80039     } catch (...) {
80040       {
80041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80042       };
80043     }
80044   }
80045
80046 }
80047
80048
80049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
80050   void * jresult ;
80051   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80052   Dali::Vector2 result;
80053
80054   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80055   {
80056     try {
80057       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
80058     } catch (std::out_of_range& e) {
80059       {
80060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80061       };
80062     } catch (std::exception& e) {
80063       {
80064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80065       };
80066     } catch (Dali::DaliException e) {
80067       {
80068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80069       };
80070     } catch (...) {
80071       {
80072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80073       };
80074     }
80075   }
80076
80077   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80078   return jresult;
80079 }
80080
80081
80082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
80083   unsigned int jresult ;
80084   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80085   unsigned int result;
80086
80087   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80088   {
80089     try {
80090       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
80091     } catch (std::out_of_range& e) {
80092       {
80093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80094       };
80095     } catch (std::exception& e) {
80096       {
80097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80098       };
80099     } catch (Dali::DaliException e) {
80100       {
80101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80102       };
80103     } catch (...) {
80104       {
80105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80106       };
80107     }
80108   }
80109
80110   jresult = result;
80111   return jresult;
80112 }
80113
80114
80115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
80116   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80117   Dali::Vector2 *arg2 = 0 ;
80118
80119   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80120   arg2 = (Dali::Vector2 *)jarg2;
80121   if (!arg2) {
80122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80123     return ;
80124   }
80125   {
80126     try {
80127       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
80128     } catch (std::out_of_range& e) {
80129       {
80130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80131       };
80132     } catch (std::exception& e) {
80133       {
80134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80135       };
80136     } catch (Dali::DaliException e) {
80137       {
80138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80139       };
80140     } catch (...) {
80141       {
80142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80143       };
80144     }
80145   }
80146
80147 }
80148
80149
80150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
80151   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80152   Dali::Vector2 *arg2 = 0 ;
80153   float arg3 ;
80154
80155   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80156   arg2 = (Dali::Vector2 *)jarg2;
80157   if (!arg2) {
80158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80159     return ;
80160   }
80161   arg3 = (float)jarg3;
80162   {
80163     try {
80164       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
80165     } catch (std::out_of_range& e) {
80166       {
80167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80168       };
80169     } catch (std::exception& e) {
80170       {
80171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80172       };
80173     } catch (Dali::DaliException e) {
80174       {
80175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80176       };
80177     } catch (...) {
80178       {
80179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80180       };
80181     }
80182   }
80183
80184 }
80185
80186
80187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
80188   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80189   Dali::Vector2 *arg2 = 0 ;
80190   float arg3 ;
80191   Dali::AlphaFunction arg4 ;
80192   Dali::AlphaFunction *argp4 ;
80193
80194   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80195   arg2 = (Dali::Vector2 *)jarg2;
80196   if (!arg2) {
80197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80198     return ;
80199   }
80200   arg3 = (float)jarg3;
80201   argp4 = (Dali::AlphaFunction *)jarg4;
80202   if (!argp4) {
80203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80204     return ;
80205   }
80206   arg4 = *argp4;
80207   {
80208     try {
80209       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
80210     } catch (std::out_of_range& e) {
80211       {
80212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80213       };
80214     } catch (std::exception& e) {
80215       {
80216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80217       };
80218     } catch (Dali::DaliException e) {
80219       {
80220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80221       };
80222     } catch (...) {
80223       {
80224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80225       };
80226     }
80227   }
80228
80229 }
80230
80231
80232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
80233   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80234   Dali::Vector2 *arg2 = 0 ;
80235   float arg3 ;
80236   Dali::Toolkit::DirectionBias arg4 ;
80237   Dali::Toolkit::DirectionBias arg5 ;
80238
80239   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80240   arg2 = (Dali::Vector2 *)jarg2;
80241   if (!arg2) {
80242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80243     return ;
80244   }
80245   arg3 = (float)jarg3;
80246   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80247   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80248   {
80249     try {
80250       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
80251     } catch (std::out_of_range& e) {
80252       {
80253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80254       };
80255     } catch (std::exception& e) {
80256       {
80257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80258       };
80259     } catch (Dali::DaliException e) {
80260       {
80261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80262       };
80263     } catch (...) {
80264       {
80265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80266       };
80267     }
80268   }
80269
80270 }
80271
80272
80273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
80274   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80275   Dali::Vector2 *arg2 = 0 ;
80276   float arg3 ;
80277   Dali::AlphaFunction arg4 ;
80278   Dali::Toolkit::DirectionBias arg5 ;
80279   Dali::Toolkit::DirectionBias arg6 ;
80280   Dali::AlphaFunction *argp4 ;
80281
80282   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80283   arg2 = (Dali::Vector2 *)jarg2;
80284   if (!arg2) {
80285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80286     return ;
80287   }
80288   arg3 = (float)jarg3;
80289   argp4 = (Dali::AlphaFunction *)jarg4;
80290   if (!argp4) {
80291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80292     return ;
80293   }
80294   arg4 = *argp4;
80295   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80296   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
80297   {
80298     try {
80299       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
80300     } catch (std::out_of_range& e) {
80301       {
80302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80303       };
80304     } catch (std::exception& e) {
80305       {
80306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80307       };
80308     } catch (Dali::DaliException e) {
80309       {
80310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80311       };
80312     } catch (...) {
80313       {
80314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80315       };
80316     }
80317   }
80318
80319 }
80320
80321
80322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
80323   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80324   unsigned int arg2 ;
80325
80326   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80327   arg2 = (unsigned int)jarg2;
80328   {
80329     try {
80330       (arg1)->ScrollTo(arg2);
80331     } catch (std::out_of_range& e) {
80332       {
80333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80334       };
80335     } catch (std::exception& e) {
80336       {
80337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80338       };
80339     } catch (Dali::DaliException e) {
80340       {
80341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80342       };
80343     } catch (...) {
80344       {
80345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80346       };
80347     }
80348   }
80349
80350 }
80351
80352
80353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
80354   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80355   unsigned int arg2 ;
80356   float arg3 ;
80357
80358   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80359   arg2 = (unsigned int)jarg2;
80360   arg3 = (float)jarg3;
80361   {
80362     try {
80363       (arg1)->ScrollTo(arg2,arg3);
80364     } catch (std::out_of_range& e) {
80365       {
80366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80367       };
80368     } catch (std::exception& e) {
80369       {
80370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80371       };
80372     } catch (Dali::DaliException e) {
80373       {
80374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80375       };
80376     } catch (...) {
80377       {
80378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80379       };
80380     }
80381   }
80382
80383 }
80384
80385
80386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
80387   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80388   unsigned int arg2 ;
80389   float arg3 ;
80390   Dali::Toolkit::DirectionBias arg4 ;
80391
80392   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80393   arg2 = (unsigned int)jarg2;
80394   arg3 = (float)jarg3;
80395   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80396   {
80397     try {
80398       (arg1)->ScrollTo(arg2,arg3,arg4);
80399     } catch (std::out_of_range& e) {
80400       {
80401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80402       };
80403     } catch (std::exception& e) {
80404       {
80405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80406       };
80407     } catch (Dali::DaliException e) {
80408       {
80409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80410       };
80411     } catch (...) {
80412       {
80413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80414       };
80415     }
80416   }
80417
80418 }
80419
80420
80421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
80422   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80423   Dali::Actor *arg2 = 0 ;
80424
80425   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80426   arg2 = (Dali::Actor *)jarg2;
80427   if (!arg2) {
80428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80429     return ;
80430   }
80431   {
80432     try {
80433       (arg1)->ScrollTo(*arg2);
80434     } catch (std::out_of_range& e) {
80435       {
80436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80437       };
80438     } catch (std::exception& e) {
80439       {
80440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80441       };
80442     } catch (Dali::DaliException e) {
80443       {
80444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80445       };
80446     } catch (...) {
80447       {
80448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80449       };
80450     }
80451   }
80452
80453 }
80454
80455
80456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
80457   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80458   Dali::Actor *arg2 = 0 ;
80459   float arg3 ;
80460
80461   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80462   arg2 = (Dali::Actor *)jarg2;
80463   if (!arg2) {
80464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80465     return ;
80466   }
80467   arg3 = (float)jarg3;
80468   {
80469     try {
80470       (arg1)->ScrollTo(*arg2,arg3);
80471     } catch (std::out_of_range& e) {
80472       {
80473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80474       };
80475     } catch (std::exception& e) {
80476       {
80477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80478       };
80479     } catch (Dali::DaliException e) {
80480       {
80481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80482       };
80483     } catch (...) {
80484       {
80485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80486       };
80487     }
80488   }
80489
80490 }
80491
80492
80493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
80494   unsigned int jresult ;
80495   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80496   bool result;
80497
80498   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80499   {
80500     try {
80501       result = (bool)(arg1)->ScrollToSnapPoint();
80502     } catch (std::out_of_range& e) {
80503       {
80504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80505       };
80506     } catch (std::exception& e) {
80507       {
80508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80509       };
80510     } catch (Dali::DaliException e) {
80511       {
80512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80513       };
80514     } catch (...) {
80515       {
80516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80517       };
80518     }
80519   }
80520
80521   jresult = result;
80522   return jresult;
80523 }
80524
80525
80526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
80527   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80528   Dali::Constraint arg2 ;
80529   Dali::Constraint *argp2 ;
80530
80531   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80532   argp2 = (Dali::Constraint *)jarg2;
80533   if (!argp2) {
80534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
80535     return ;
80536   }
80537   arg2 = *argp2;
80538   {
80539     try {
80540       (arg1)->ApplyConstraintToChildren(arg2);
80541     } catch (std::out_of_range& e) {
80542       {
80543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80544       };
80545     } catch (std::exception& e) {
80546       {
80547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80548       };
80549     } catch (Dali::DaliException e) {
80550       {
80551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80552       };
80553     } catch (...) {
80554       {
80555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80556       };
80557     }
80558   }
80559
80560 }
80561
80562
80563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
80564   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80565
80566   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80567   {
80568     try {
80569       (arg1)->RemoveConstraintsFromChildren();
80570     } catch (std::out_of_range& e) {
80571       {
80572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80573       };
80574     } catch (std::exception& e) {
80575       {
80576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80577       };
80578     } catch (Dali::DaliException e) {
80579       {
80580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80581       };
80582     } catch (...) {
80583       {
80584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80585       };
80586     }
80587   }
80588
80589 }
80590
80591
80592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
80593   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80594   Dali::Toolkit::ScrollViewEffect arg2 ;
80595   Dali::Toolkit::ScrollViewEffect *argp2 ;
80596
80597   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80598   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80599   if (!argp2) {
80600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80601     return ;
80602   }
80603   arg2 = *argp2;
80604   {
80605     try {
80606       (arg1)->ApplyEffect(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 void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
80630   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80631   Dali::Toolkit::ScrollViewEffect arg2 ;
80632   Dali::Toolkit::ScrollViewEffect *argp2 ;
80633
80634   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80635   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80636   if (!argp2) {
80637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80638     return ;
80639   }
80640   arg2 = *argp2;
80641   {
80642     try {
80643       (arg1)->RemoveEffect(arg2);
80644     } catch (std::out_of_range& e) {
80645       {
80646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80647       };
80648     } catch (std::exception& e) {
80649       {
80650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80651       };
80652     } catch (Dali::DaliException e) {
80653       {
80654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80655       };
80656     } catch (...) {
80657       {
80658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80659       };
80660     }
80661   }
80662
80663 }
80664
80665
80666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
80667   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80668
80669   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80670   {
80671     try {
80672       (arg1)->RemoveAllEffects();
80673     } catch (std::out_of_range& e) {
80674       {
80675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80676       };
80677     } catch (std::exception& e) {
80678       {
80679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80680       };
80681     } catch (Dali::DaliException e) {
80682       {
80683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80684       };
80685     } catch (...) {
80686       {
80687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80688       };
80689     }
80690   }
80691
80692 }
80693
80694
80695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
80696   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80697   Dali::Actor arg2 ;
80698   Dali::Actor *argp2 ;
80699
80700   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80701   argp2 = (Dali::Actor *)jarg2;
80702   if (!argp2) {
80703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80704     return ;
80705   }
80706   arg2 = *argp2;
80707   {
80708     try {
80709       (arg1)->BindActor(arg2);
80710     } catch (std::out_of_range& e) {
80711       {
80712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80713       };
80714     } catch (std::exception& e) {
80715       {
80716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80717       };
80718     } catch (Dali::DaliException e) {
80719       {
80720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80721       };
80722     } catch (...) {
80723       {
80724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80725       };
80726     }
80727   }
80728
80729 }
80730
80731
80732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
80733   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80734   Dali::Actor arg2 ;
80735   Dali::Actor *argp2 ;
80736
80737   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80738   argp2 = (Dali::Actor *)jarg2;
80739   if (!argp2) {
80740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80741     return ;
80742   }
80743   arg2 = *argp2;
80744   {
80745     try {
80746       (arg1)->UnbindActor(arg2);
80747     } catch (std::out_of_range& e) {
80748       {
80749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80750       };
80751     } catch (std::exception& e) {
80752       {
80753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80754       };
80755     } catch (Dali::DaliException e) {
80756       {
80757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80758       };
80759     } catch (...) {
80760       {
80761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80762       };
80763     }
80764   }
80765
80766 }
80767
80768
80769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
80770   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80771   Dali::Radian arg2 ;
80772   Dali::Radian arg3 ;
80773   Dali::Radian *argp2 ;
80774   Dali::Radian *argp3 ;
80775
80776   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80777   argp2 = (Dali::Radian *)jarg2;
80778   if (!argp2) {
80779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80780     return ;
80781   }
80782   arg2 = *argp2;
80783   argp3 = (Dali::Radian *)jarg3;
80784   if (!argp3) {
80785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80786     return ;
80787   }
80788   arg3 = *argp3;
80789   {
80790     try {
80791       (arg1)->SetScrollingDirection(arg2,arg3);
80792     } catch (std::out_of_range& e) {
80793       {
80794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80795       };
80796     } catch (std::exception& e) {
80797       {
80798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80799       };
80800     } catch (Dali::DaliException e) {
80801       {
80802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80803       };
80804     } catch (...) {
80805       {
80806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80807       };
80808     }
80809   }
80810
80811 }
80812
80813
80814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
80815   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80816   Dali::Radian arg2 ;
80817   Dali::Radian *argp2 ;
80818
80819   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80820   argp2 = (Dali::Radian *)jarg2;
80821   if (!argp2) {
80822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80823     return ;
80824   }
80825   arg2 = *argp2;
80826   {
80827     try {
80828       (arg1)->SetScrollingDirection(arg2);
80829     } catch (std::out_of_range& e) {
80830       {
80831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80832       };
80833     } catch (std::exception& e) {
80834       {
80835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80836       };
80837     } catch (Dali::DaliException e) {
80838       {
80839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80840       };
80841     } catch (...) {
80842       {
80843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80844       };
80845     }
80846   }
80847
80848 }
80849
80850
80851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
80852   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80853   Dali::Radian arg2 ;
80854   Dali::Radian *argp2 ;
80855
80856   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80857   argp2 = (Dali::Radian *)jarg2;
80858   if (!argp2) {
80859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80860     return ;
80861   }
80862   arg2 = *argp2;
80863   {
80864     try {
80865       (arg1)->RemoveScrollingDirection(arg2);
80866     } catch (std::out_of_range& e) {
80867       {
80868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80869       };
80870     } catch (std::exception& e) {
80871       {
80872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80873       };
80874     } catch (Dali::DaliException e) {
80875       {
80876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80877       };
80878     } catch (...) {
80879       {
80880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80881       };
80882     }
80883   }
80884
80885 }
80886
80887
80888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
80889   void * jresult ;
80890   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80891   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
80892
80893   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80894   {
80895     try {
80896       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
80897     } catch (std::out_of_range& e) {
80898       {
80899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80900       };
80901     } catch (std::exception& e) {
80902       {
80903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80904       };
80905     } catch (Dali::DaliException e) {
80906       {
80907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80908       };
80909     } catch (...) {
80910       {
80911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80912       };
80913     }
80914   }
80915
80916   jresult = (void *)result;
80917   return jresult;
80918 }
80919
80920
80921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
80922   int jresult ;
80923   int result;
80924
80925   result = (int)Dali::Toolkit::TableView::Property::ROWS;
80926   jresult = (int)result;
80927   return jresult;
80928 }
80929
80930
80931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
80932   int jresult ;
80933   int result;
80934
80935   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
80936   jresult = (int)result;
80937   return jresult;
80938 }
80939
80940
80941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
80942   int jresult ;
80943   int result;
80944
80945   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
80946   jresult = (int)result;
80947   return jresult;
80948 }
80949
80950
80951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
80952   int jresult ;
80953   int result;
80954
80955   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
80956   jresult = (int)result;
80957   return jresult;
80958 }
80959
80960
80961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
80962   int jresult ;
80963   int result;
80964
80965   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
80966   jresult = (int)result;
80967   return jresult;
80968 }
80969
80970
80971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
80972   void * jresult ;
80973   Dali::Toolkit::TableView::Property *result = 0 ;
80974
80975   {
80976     try {
80977       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
80978     } catch (std::out_of_range& e) {
80979       {
80980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80981       };
80982     } catch (std::exception& e) {
80983       {
80984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80985       };
80986     } catch (Dali::DaliException e) {
80987       {
80988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80989       };
80990     } catch (...) {
80991       {
80992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80993       };
80994     }
80995   }
80996
80997   jresult = (void *)result;
80998   return jresult;
80999 }
81000
81001
81002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
81003   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
81004
81005   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
81006   {
81007     try {
81008       delete arg1;
81009     } catch (std::out_of_range& e) {
81010       {
81011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81012       };
81013     } catch (std::exception& e) {
81014       {
81015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81016       };
81017     } catch (Dali::DaliException e) {
81018       {
81019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81020       };
81021     } catch (...) {
81022       {
81023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81024       };
81025     }
81026   }
81027
81028 }
81029
81030
81031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
81032   int jresult ;
81033   int result;
81034
81035   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
81036   jresult = (int)result;
81037   return jresult;
81038 }
81039
81040
81041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
81042   int jresult ;
81043   int result;
81044
81045   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
81046   jresult = (int)result;
81047   return jresult;
81048 }
81049
81050
81051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
81052   int jresult ;
81053   int result;
81054
81055   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
81056   jresult = (int)result;
81057   return jresult;
81058 }
81059
81060
81061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
81062   int jresult ;
81063   int result;
81064
81065   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
81066   jresult = (int)result;
81067   return jresult;
81068 }
81069
81070
81071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
81072   int jresult ;
81073   int result;
81074
81075   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
81076   jresult = (int)result;
81077   return jresult;
81078 }
81079
81080
81081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
81082   void * jresult ;
81083   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
81084
81085   {
81086     try {
81087       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
81088     } catch (std::out_of_range& e) {
81089       {
81090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81091       };
81092     } catch (std::exception& e) {
81093       {
81094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81095       };
81096     } catch (Dali::DaliException e) {
81097       {
81098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81099       };
81100     } catch (...) {
81101       {
81102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81103       };
81104     }
81105   }
81106
81107   jresult = (void *)result;
81108   return jresult;
81109 }
81110
81111
81112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
81113   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
81114
81115   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
81116   {
81117     try {
81118       delete arg1;
81119     } catch (std::out_of_range& e) {
81120       {
81121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81122       };
81123     } catch (std::exception& e) {
81124       {
81125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81126       };
81127     } catch (Dali::DaliException e) {
81128       {
81129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81130       };
81131     } catch (...) {
81132       {
81133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81134       };
81135     }
81136   }
81137
81138 }
81139
81140
81141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
81142   void * jresult ;
81143   unsigned int arg1 ;
81144   unsigned int arg2 ;
81145   unsigned int arg3 ;
81146   unsigned int arg4 ;
81147   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81148
81149   arg1 = (unsigned int)jarg1;
81150   arg2 = (unsigned int)jarg2;
81151   arg3 = (unsigned int)jarg3;
81152   arg4 = (unsigned int)jarg4;
81153   {
81154     try {
81155       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
81156     } catch (std::out_of_range& e) {
81157       {
81158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81159       };
81160     } catch (std::exception& e) {
81161       {
81162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81163       };
81164     } catch (Dali::DaliException e) {
81165       {
81166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81167       };
81168     } catch (...) {
81169       {
81170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81171       };
81172     }
81173   }
81174
81175   jresult = (void *)result;
81176   return jresult;
81177 }
81178
81179
81180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
81181   void * jresult ;
81182   unsigned int arg1 ;
81183   unsigned int arg2 ;
81184   unsigned int arg3 ;
81185   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81186
81187   arg1 = (unsigned int)jarg1;
81188   arg2 = (unsigned int)jarg2;
81189   arg3 = (unsigned int)jarg3;
81190   {
81191     try {
81192       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
81193     } catch (std::out_of_range& e) {
81194       {
81195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81196       };
81197     } catch (std::exception& e) {
81198       {
81199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81200       };
81201     } catch (Dali::DaliException e) {
81202       {
81203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81204       };
81205     } catch (...) {
81206       {
81207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81208       };
81209     }
81210   }
81211
81212   jresult = (void *)result;
81213   return jresult;
81214 }
81215
81216
81217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
81218   void * jresult ;
81219   unsigned int arg1 ;
81220   unsigned int arg2 ;
81221   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81222
81223   arg1 = (unsigned int)jarg1;
81224   arg2 = (unsigned int)jarg2;
81225   {
81226     try {
81227       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
81228     } catch (std::out_of_range& e) {
81229       {
81230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81231       };
81232     } catch (std::exception& e) {
81233       {
81234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81235       };
81236     } catch (Dali::DaliException e) {
81237       {
81238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81239       };
81240     } catch (...) {
81241       {
81242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81243       };
81244     }
81245   }
81246
81247   jresult = (void *)result;
81248   return jresult;
81249 }
81250
81251
81252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
81253   void * jresult ;
81254   unsigned int arg1 ;
81255   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81256
81257   arg1 = (unsigned int)jarg1;
81258   {
81259     try {
81260       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
81261     } catch (std::out_of_range& e) {
81262       {
81263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81264       };
81265     } catch (std::exception& e) {
81266       {
81267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81268       };
81269     } catch (Dali::DaliException e) {
81270       {
81271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81272       };
81273     } catch (...) {
81274       {
81275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81276       };
81277     }
81278   }
81279
81280   jresult = (void *)result;
81281   return jresult;
81282 }
81283
81284
81285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
81286   void * jresult ;
81287   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81288
81289   {
81290     try {
81291       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
81292     } catch (std::out_of_range& e) {
81293       {
81294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81295       };
81296     } catch (std::exception& e) {
81297       {
81298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81299       };
81300     } catch (Dali::DaliException e) {
81301       {
81302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81303       };
81304     } catch (...) {
81305       {
81306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81307       };
81308     }
81309   }
81310
81311   jresult = (void *)result;
81312   return jresult;
81313 }
81314
81315
81316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
81317   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81318   unsigned int arg2 ;
81319
81320   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81321   arg2 = (unsigned int)jarg2;
81322   if (arg1) (arg1)->rowIndex = arg2;
81323 }
81324
81325
81326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
81327   unsigned int jresult ;
81328   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81329   unsigned int result;
81330
81331   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81332   result = (unsigned int) ((arg1)->rowIndex);
81333   jresult = result;
81334   return jresult;
81335 }
81336
81337
81338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
81339   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81340   unsigned int arg2 ;
81341
81342   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81343   arg2 = (unsigned int)jarg2;
81344   if (arg1) (arg1)->columnIndex = arg2;
81345 }
81346
81347
81348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
81349   unsigned int jresult ;
81350   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81351   unsigned int result;
81352
81353   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81354   result = (unsigned int) ((arg1)->columnIndex);
81355   jresult = result;
81356   return jresult;
81357 }
81358
81359
81360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
81361   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81362   unsigned int arg2 ;
81363
81364   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81365   arg2 = (unsigned int)jarg2;
81366   if (arg1) (arg1)->rowSpan = arg2;
81367 }
81368
81369
81370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
81371   unsigned int jresult ;
81372   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81373   unsigned int result;
81374
81375   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81376   result = (unsigned int) ((arg1)->rowSpan);
81377   jresult = result;
81378   return jresult;
81379 }
81380
81381
81382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
81383   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81384   unsigned int arg2 ;
81385
81386   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81387   arg2 = (unsigned int)jarg2;
81388   if (arg1) (arg1)->columnSpan = arg2;
81389 }
81390
81391
81392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
81393   unsigned int jresult ;
81394   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81395   unsigned int result;
81396
81397   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81398   result = (unsigned int) ((arg1)->columnSpan);
81399   jresult = result;
81400   return jresult;
81401 }
81402
81403
81404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
81405   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81406
81407   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81408   {
81409     try {
81410       delete arg1;
81411     } catch (std::out_of_range& e) {
81412       {
81413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81414       };
81415     } catch (std::exception& e) {
81416       {
81417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81418       };
81419     } catch (Dali::DaliException e) {
81420       {
81421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81422       };
81423     } catch (...) {
81424       {
81425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81426       };
81427     }
81428   }
81429
81430 }
81431
81432
81433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
81434   void * jresult ;
81435   Dali::Toolkit::TableView *result = 0 ;
81436
81437   {
81438     try {
81439       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
81440     } catch (std::out_of_range& e) {
81441       {
81442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81443       };
81444     } catch (std::exception& e) {
81445       {
81446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81447       };
81448     } catch (Dali::DaliException e) {
81449       {
81450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81451       };
81452     } catch (...) {
81453       {
81454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81455       };
81456     }
81457   }
81458
81459   jresult = (void *)result;
81460   return jresult;
81461 }
81462
81463
81464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
81465   void * jresult ;
81466   Dali::Toolkit::TableView *arg1 = 0 ;
81467   Dali::Toolkit::TableView *result = 0 ;
81468
81469   arg1 = (Dali::Toolkit::TableView *)jarg1;
81470   if (!arg1) {
81471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81472     return 0;
81473   }
81474   {
81475     try {
81476       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
81477     } catch (std::out_of_range& e) {
81478       {
81479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81480       };
81481     } catch (std::exception& e) {
81482       {
81483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81484       };
81485     } catch (Dali::DaliException e) {
81486       {
81487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81488       };
81489     } catch (...) {
81490       {
81491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81492       };
81493     }
81494   }
81495
81496   jresult = (void *)result;
81497   return jresult;
81498 }
81499
81500
81501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
81502   void * jresult ;
81503   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81504   Dali::Toolkit::TableView *arg2 = 0 ;
81505   Dali::Toolkit::TableView *result = 0 ;
81506
81507   arg1 = (Dali::Toolkit::TableView *)jarg1;
81508   arg2 = (Dali::Toolkit::TableView *)jarg2;
81509   if (!arg2) {
81510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81511     return 0;
81512   }
81513   {
81514     try {
81515       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
81516     } catch (std::out_of_range& e) {
81517       {
81518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81519       };
81520     } catch (std::exception& e) {
81521       {
81522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81523       };
81524     } catch (Dali::DaliException e) {
81525       {
81526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81527       };
81528     } catch (...) {
81529       {
81530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81531       };
81532     }
81533   }
81534
81535   jresult = (void *)result;
81536   return jresult;
81537 }
81538
81539
81540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
81541   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81542
81543   arg1 = (Dali::Toolkit::TableView *)jarg1;
81544   {
81545     try {
81546       delete arg1;
81547     } catch (std::out_of_range& e) {
81548       {
81549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81550       };
81551     } catch (std::exception& e) {
81552       {
81553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81554       };
81555     } catch (Dali::DaliException e) {
81556       {
81557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81558       };
81559     } catch (...) {
81560       {
81561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81562       };
81563     }
81564   }
81565
81566 }
81567
81568
81569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
81570   void * jresult ;
81571   unsigned int arg1 ;
81572   unsigned int arg2 ;
81573   Dali::Toolkit::TableView result;
81574
81575   arg1 = (unsigned int)jarg1;
81576   arg2 = (unsigned int)jarg2;
81577   {
81578     try {
81579       result = Dali::Toolkit::TableView::New(arg1,arg2);
81580     } catch (std::out_of_range& e) {
81581       {
81582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81583       };
81584     } catch (std::exception& e) {
81585       {
81586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81587       };
81588     } catch (Dali::DaliException e) {
81589       {
81590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81591       };
81592     } catch (...) {
81593       {
81594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81595       };
81596     }
81597   }
81598
81599   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81600   return jresult;
81601 }
81602
81603
81604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
81605   void * jresult ;
81606   Dali::BaseHandle arg1 ;
81607   Dali::BaseHandle *argp1 ;
81608   Dali::Toolkit::TableView result;
81609
81610   argp1 = (Dali::BaseHandle *)jarg1;
81611   if (!argp1) {
81612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81613     return 0;
81614   }
81615   arg1 = *argp1;
81616   {
81617     try {
81618       result = Dali::Toolkit::TableView::DownCast(arg1);
81619     } catch (std::out_of_range& e) {
81620       {
81621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81622       };
81623     } catch (std::exception& e) {
81624       {
81625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81626       };
81627     } catch (Dali::DaliException e) {
81628       {
81629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81630       };
81631     } catch (...) {
81632       {
81633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81634       };
81635     }
81636   }
81637
81638   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81639   return jresult;
81640 }
81641
81642
81643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
81644   unsigned int jresult ;
81645   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81646   Dali::Actor arg2 ;
81647   Dali::Toolkit::TableView::CellPosition arg3 ;
81648   Dali::Actor *argp2 ;
81649   Dali::Toolkit::TableView::CellPosition *argp3 ;
81650   bool result;
81651
81652   arg1 = (Dali::Toolkit::TableView *)jarg1;
81653   argp2 = (Dali::Actor *)jarg2;
81654   if (!argp2) {
81655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81656     return 0;
81657   }
81658   arg2 = *argp2;
81659   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81660   if (!argp3) {
81661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81662     return 0;
81663   }
81664   arg3 = *argp3;
81665   {
81666     try {
81667       result = (bool)(arg1)->AddChild(arg2,arg3);
81668     } catch (std::out_of_range& e) {
81669       {
81670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81671       };
81672     } catch (std::exception& e) {
81673       {
81674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81675       };
81676     } catch (Dali::DaliException e) {
81677       {
81678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81679       };
81680     } catch (...) {
81681       {
81682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81683       };
81684     }
81685   }
81686
81687   jresult = result;
81688   return jresult;
81689 }
81690
81691
81692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
81693   void * jresult ;
81694   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81695   Dali::Toolkit::TableView::CellPosition arg2 ;
81696   Dali::Toolkit::TableView::CellPosition *argp2 ;
81697   Dali::Actor result;
81698
81699   arg1 = (Dali::Toolkit::TableView *)jarg1;
81700   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81701   if (!argp2) {
81702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81703     return 0;
81704   }
81705   arg2 = *argp2;
81706   {
81707     try {
81708       result = (arg1)->GetChildAt(arg2);
81709     } catch (std::out_of_range& e) {
81710       {
81711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81712       };
81713     } catch (std::exception& e) {
81714       {
81715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81716       };
81717     } catch (Dali::DaliException e) {
81718       {
81719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81720       };
81721     } catch (...) {
81722       {
81723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81724       };
81725     }
81726   }
81727
81728   jresult = new Dali::Actor((const Dali::Actor &)result);
81729   return jresult;
81730 }
81731
81732
81733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
81734   void * jresult ;
81735   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81736   Dali::Toolkit::TableView::CellPosition arg2 ;
81737   Dali::Toolkit::TableView::CellPosition *argp2 ;
81738   Dali::Actor result;
81739
81740   arg1 = (Dali::Toolkit::TableView *)jarg1;
81741   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81742   if (!argp2) {
81743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81744     return 0;
81745   }
81746   arg2 = *argp2;
81747   {
81748     try {
81749       result = (arg1)->RemoveChildAt(arg2);
81750     } catch (std::out_of_range& e) {
81751       {
81752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81753       };
81754     } catch (std::exception& e) {
81755       {
81756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81757       };
81758     } catch (Dali::DaliException e) {
81759       {
81760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81761       };
81762     } catch (...) {
81763       {
81764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81765       };
81766     }
81767   }
81768
81769   jresult = new Dali::Actor((const Dali::Actor &)result);
81770   return jresult;
81771 }
81772
81773
81774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
81775   unsigned int jresult ;
81776   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81777   Dali::Actor arg2 ;
81778   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
81779   Dali::Actor *argp2 ;
81780   bool result;
81781
81782   arg1 = (Dali::Toolkit::TableView *)jarg1;
81783   argp2 = (Dali::Actor *)jarg2;
81784   if (!argp2) {
81785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81786     return 0;
81787   }
81788   arg2 = *argp2;
81789   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81790   if (!arg3) {
81791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
81792     return 0;
81793   }
81794   {
81795     try {
81796       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
81797     } catch (std::out_of_range& e) {
81798       {
81799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81800       };
81801     } catch (std::exception& e) {
81802       {
81803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81804       };
81805     } catch (Dali::DaliException e) {
81806       {
81807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81808       };
81809     } catch (...) {
81810       {
81811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81812       };
81813     }
81814   }
81815
81816   jresult = result;
81817   return jresult;
81818 }
81819
81820
81821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
81822   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81823   unsigned int arg2 ;
81824
81825   arg1 = (Dali::Toolkit::TableView *)jarg1;
81826   arg2 = (unsigned int)jarg2;
81827   {
81828     try {
81829       (arg1)->InsertRow(arg2);
81830     } catch (std::out_of_range& e) {
81831       {
81832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81833       };
81834     } catch (std::exception& e) {
81835       {
81836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81837       };
81838     } catch (Dali::DaliException e) {
81839       {
81840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81841       };
81842     } catch (...) {
81843       {
81844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81845       };
81846     }
81847   }
81848
81849 }
81850
81851
81852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
81853   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81854   unsigned int arg2 ;
81855
81856   arg1 = (Dali::Toolkit::TableView *)jarg1;
81857   arg2 = (unsigned int)jarg2;
81858   {
81859     try {
81860       (arg1)->DeleteRow(arg2);
81861     } catch (std::out_of_range& e) {
81862       {
81863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81864       };
81865     } catch (std::exception& e) {
81866       {
81867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81868       };
81869     } catch (Dali::DaliException e) {
81870       {
81871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81872       };
81873     } catch (...) {
81874       {
81875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81876       };
81877     }
81878   }
81879
81880 }
81881
81882
81883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
81884   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81885   unsigned int arg2 ;
81886   std::vector< Dali::Actor > *arg3 = 0 ;
81887
81888   arg1 = (Dali::Toolkit::TableView *)jarg1;
81889   arg2 = (unsigned int)jarg2;
81890   arg3 = (std::vector< Dali::Actor > *)jarg3;
81891   if (!arg3) {
81892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
81893     return ;
81894   }
81895   {
81896     try {
81897       (arg1)->DeleteRow(arg2,*arg3);
81898     } catch (std::out_of_range& e) {
81899       {
81900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81901       };
81902     } catch (std::exception& e) {
81903       {
81904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81905       };
81906     } catch (Dali::DaliException e) {
81907       {
81908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81909       };
81910     } catch (...) {
81911       {
81912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81913       };
81914     }
81915   }
81916
81917 }
81918
81919
81920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
81921   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81922   unsigned int arg2 ;
81923
81924   arg1 = (Dali::Toolkit::TableView *)jarg1;
81925   arg2 = (unsigned int)jarg2;
81926   {
81927     try {
81928       (arg1)->InsertColumn(arg2);
81929     } catch (std::out_of_range& e) {
81930       {
81931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81932       };
81933     } catch (std::exception& e) {
81934       {
81935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81936       };
81937     } catch (Dali::DaliException e) {
81938       {
81939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81940       };
81941     } catch (...) {
81942       {
81943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81944       };
81945     }
81946   }
81947
81948 }
81949
81950
81951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
81952   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81953   unsigned int arg2 ;
81954
81955   arg1 = (Dali::Toolkit::TableView *)jarg1;
81956   arg2 = (unsigned int)jarg2;
81957   {
81958     try {
81959       (arg1)->DeleteColumn(arg2);
81960     } catch (std::out_of_range& e) {
81961       {
81962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81963       };
81964     } catch (std::exception& e) {
81965       {
81966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81967       };
81968     } catch (Dali::DaliException e) {
81969       {
81970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81971       };
81972     } catch (...) {
81973       {
81974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81975       };
81976     }
81977   }
81978
81979 }
81980
81981
81982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
81983   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81984   unsigned int arg2 ;
81985   std::vector< Dali::Actor > *arg3 = 0 ;
81986
81987   arg1 = (Dali::Toolkit::TableView *)jarg1;
81988   arg2 = (unsigned int)jarg2;
81989   arg3 = (std::vector< Dali::Actor > *)jarg3;
81990   if (!arg3) {
81991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
81992     return ;
81993   }
81994   {
81995     try {
81996       (arg1)->DeleteColumn(arg2,*arg3);
81997     } catch (std::out_of_range& e) {
81998       {
81999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82000       };
82001     } catch (std::exception& e) {
82002       {
82003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82004       };
82005     } catch (Dali::DaliException e) {
82006       {
82007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82008       };
82009     } catch (...) {
82010       {
82011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82012       };
82013     }
82014   }
82015
82016 }
82017
82018
82019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
82020   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82021   unsigned int arg2 ;
82022   unsigned int arg3 ;
82023
82024   arg1 = (Dali::Toolkit::TableView *)jarg1;
82025   arg2 = (unsigned int)jarg2;
82026   arg3 = (unsigned int)jarg3;
82027   {
82028     try {
82029       (arg1)->Resize(arg2,arg3);
82030     } catch (std::out_of_range& e) {
82031       {
82032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82033       };
82034     } catch (std::exception& e) {
82035       {
82036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82037       };
82038     } catch (Dali::DaliException e) {
82039       {
82040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82041       };
82042     } catch (...) {
82043       {
82044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82045       };
82046     }
82047   }
82048
82049 }
82050
82051
82052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
82053   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82054   unsigned int arg2 ;
82055   unsigned int arg3 ;
82056   std::vector< Dali::Actor > *arg4 = 0 ;
82057
82058   arg1 = (Dali::Toolkit::TableView *)jarg1;
82059   arg2 = (unsigned int)jarg2;
82060   arg3 = (unsigned int)jarg3;
82061   arg4 = (std::vector< Dali::Actor > *)jarg4;
82062   if (!arg4) {
82063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82064     return ;
82065   }
82066   {
82067     try {
82068       (arg1)->Resize(arg2,arg3,*arg4);
82069     } catch (std::out_of_range& e) {
82070       {
82071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82072       };
82073     } catch (std::exception& e) {
82074       {
82075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82076       };
82077     } catch (Dali::DaliException e) {
82078       {
82079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82080       };
82081     } catch (...) {
82082       {
82083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82084       };
82085     }
82086   }
82087
82088 }
82089
82090
82091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
82092   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82093   Dali::Size arg2 ;
82094   Dali::Size *argp2 ;
82095
82096   arg1 = (Dali::Toolkit::TableView *)jarg1;
82097   argp2 = (Dali::Size *)jarg2;
82098   if (!argp2) {
82099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
82100     return ;
82101   }
82102   arg2 = *argp2;
82103   {
82104     try {
82105       (arg1)->SetCellPadding(arg2);
82106     } catch (std::out_of_range& e) {
82107       {
82108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82109       };
82110     } catch (std::exception& e) {
82111       {
82112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82113       };
82114     } catch (Dali::DaliException e) {
82115       {
82116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82117       };
82118     } catch (...) {
82119       {
82120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82121       };
82122     }
82123   }
82124
82125 }
82126
82127
82128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
82129   void * jresult ;
82130   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82131   Dali::Size result;
82132
82133   arg1 = (Dali::Toolkit::TableView *)jarg1;
82134   {
82135     try {
82136       result = (arg1)->GetCellPadding();
82137     } catch (std::out_of_range& e) {
82138       {
82139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82140       };
82141     } catch (std::exception& e) {
82142       {
82143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82144       };
82145     } catch (Dali::DaliException e) {
82146       {
82147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82148       };
82149     } catch (...) {
82150       {
82151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82152       };
82153     }
82154   }
82155
82156   jresult = new Dali::Size((const Dali::Size &)result);
82157   return jresult;
82158 }
82159
82160
82161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
82162   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82163   unsigned int arg2 ;
82164
82165   arg1 = (Dali::Toolkit::TableView *)jarg1;
82166   arg2 = (unsigned int)jarg2;
82167   {
82168     try {
82169       (arg1)->SetFitHeight(arg2);
82170     } catch (std::out_of_range& e) {
82171       {
82172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82173       };
82174     } catch (std::exception& e) {
82175       {
82176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82177       };
82178     } catch (Dali::DaliException e) {
82179       {
82180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82181       };
82182     } catch (...) {
82183       {
82184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82185       };
82186     }
82187   }
82188
82189 }
82190
82191
82192 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
82193   unsigned int jresult ;
82194   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82195   unsigned int arg2 ;
82196   bool result;
82197
82198   arg1 = (Dali::Toolkit::TableView *)jarg1;
82199   arg2 = (unsigned int)jarg2;
82200   {
82201     try {
82202       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
82203     } catch (std::out_of_range& e) {
82204       {
82205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82206       };
82207     } catch (std::exception& e) {
82208       {
82209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82210       };
82211     } catch (Dali::DaliException e) {
82212       {
82213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82214       };
82215     } catch (...) {
82216       {
82217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82218       };
82219     }
82220   }
82221
82222   jresult = result;
82223   return jresult;
82224 }
82225
82226
82227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
82228   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82229   unsigned int arg2 ;
82230
82231   arg1 = (Dali::Toolkit::TableView *)jarg1;
82232   arg2 = (unsigned int)jarg2;
82233   {
82234     try {
82235       (arg1)->SetFitWidth(arg2);
82236     } catch (std::out_of_range& e) {
82237       {
82238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82239       };
82240     } catch (std::exception& e) {
82241       {
82242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82243       };
82244     } catch (Dali::DaliException e) {
82245       {
82246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82247       };
82248     } catch (...) {
82249       {
82250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82251       };
82252     }
82253   }
82254
82255 }
82256
82257
82258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
82259   unsigned int jresult ;
82260   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82261   unsigned int arg2 ;
82262   bool result;
82263
82264   arg1 = (Dali::Toolkit::TableView *)jarg1;
82265   arg2 = (unsigned int)jarg2;
82266   {
82267     try {
82268       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
82269     } catch (std::out_of_range& e) {
82270       {
82271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82272       };
82273     } catch (std::exception& e) {
82274       {
82275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82276       };
82277     } catch (Dali::DaliException e) {
82278       {
82279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82280       };
82281     } catch (...) {
82282       {
82283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82284       };
82285     }
82286   }
82287
82288   jresult = result;
82289   return jresult;
82290 }
82291
82292
82293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82294   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82295   unsigned int arg2 ;
82296   float arg3 ;
82297
82298   arg1 = (Dali::Toolkit::TableView *)jarg1;
82299   arg2 = (unsigned int)jarg2;
82300   arg3 = (float)jarg3;
82301   {
82302     try {
82303       (arg1)->SetFixedHeight(arg2,arg3);
82304     } catch (std::out_of_range& e) {
82305       {
82306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82307       };
82308     } catch (std::exception& e) {
82309       {
82310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82311       };
82312     } catch (Dali::DaliException e) {
82313       {
82314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82315       };
82316     } catch (...) {
82317       {
82318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82319       };
82320     }
82321   }
82322
82323 }
82324
82325
82326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
82327   float jresult ;
82328   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82329   unsigned int arg2 ;
82330   float result;
82331
82332   arg1 = (Dali::Toolkit::TableView *)jarg1;
82333   arg2 = (unsigned int)jarg2;
82334   {
82335     try {
82336       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
82337     } catch (std::out_of_range& e) {
82338       {
82339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82340       };
82341     } catch (std::exception& e) {
82342       {
82343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82344       };
82345     } catch (Dali::DaliException e) {
82346       {
82347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82348       };
82349     } catch (...) {
82350       {
82351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82352       };
82353     }
82354   }
82355
82356   jresult = result;
82357   return jresult;
82358 }
82359
82360
82361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82362   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82363   unsigned int arg2 ;
82364   float arg3 ;
82365
82366   arg1 = (Dali::Toolkit::TableView *)jarg1;
82367   arg2 = (unsigned int)jarg2;
82368   arg3 = (float)jarg3;
82369   {
82370     try {
82371       (arg1)->SetRelativeHeight(arg2,arg3);
82372     } catch (std::out_of_range& e) {
82373       {
82374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82375       };
82376     } catch (std::exception& e) {
82377       {
82378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82379       };
82380     } catch (Dali::DaliException e) {
82381       {
82382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82383       };
82384     } catch (...) {
82385       {
82386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82387       };
82388     }
82389   }
82390
82391 }
82392
82393
82394 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
82395   float jresult ;
82396   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82397   unsigned int arg2 ;
82398   float result;
82399
82400   arg1 = (Dali::Toolkit::TableView *)jarg1;
82401   arg2 = (unsigned int)jarg2;
82402   {
82403     try {
82404       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
82405     } catch (std::out_of_range& e) {
82406       {
82407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82408       };
82409     } catch (std::exception& e) {
82410       {
82411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82412       };
82413     } catch (Dali::DaliException e) {
82414       {
82415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82416       };
82417     } catch (...) {
82418       {
82419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82420       };
82421     }
82422   }
82423
82424   jresult = result;
82425   return jresult;
82426 }
82427
82428
82429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82430   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82431   unsigned int arg2 ;
82432   float arg3 ;
82433
82434   arg1 = (Dali::Toolkit::TableView *)jarg1;
82435   arg2 = (unsigned int)jarg2;
82436   arg3 = (float)jarg3;
82437   {
82438     try {
82439       (arg1)->SetFixedWidth(arg2,arg3);
82440     } catch (std::out_of_range& e) {
82441       {
82442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82443       };
82444     } catch (std::exception& e) {
82445       {
82446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82447       };
82448     } catch (Dali::DaliException e) {
82449       {
82450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82451       };
82452     } catch (...) {
82453       {
82454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82455       };
82456     }
82457   }
82458
82459 }
82460
82461
82462 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
82463   float jresult ;
82464   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82465   unsigned int arg2 ;
82466   float result;
82467
82468   arg1 = (Dali::Toolkit::TableView *)jarg1;
82469   arg2 = (unsigned int)jarg2;
82470   {
82471     try {
82472       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
82473     } catch (std::out_of_range& e) {
82474       {
82475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82476       };
82477     } catch (std::exception& e) {
82478       {
82479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82480       };
82481     } catch (Dali::DaliException e) {
82482       {
82483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82484       };
82485     } catch (...) {
82486       {
82487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82488       };
82489     }
82490   }
82491
82492   jresult = result;
82493   return jresult;
82494 }
82495
82496
82497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82498   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82499   unsigned int arg2 ;
82500   float arg3 ;
82501
82502   arg1 = (Dali::Toolkit::TableView *)jarg1;
82503   arg2 = (unsigned int)jarg2;
82504   arg3 = (float)jarg3;
82505   {
82506     try {
82507       (arg1)->SetRelativeWidth(arg2,arg3);
82508     } catch (std::out_of_range& e) {
82509       {
82510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82511       };
82512     } catch (std::exception& e) {
82513       {
82514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82515       };
82516     } catch (Dali::DaliException e) {
82517       {
82518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82519       };
82520     } catch (...) {
82521       {
82522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82523       };
82524     }
82525   }
82526
82527 }
82528
82529
82530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
82531   float jresult ;
82532   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82533   unsigned int arg2 ;
82534   float result;
82535
82536   arg1 = (Dali::Toolkit::TableView *)jarg1;
82537   arg2 = (unsigned int)jarg2;
82538   {
82539     try {
82540       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
82541     } catch (std::out_of_range& e) {
82542       {
82543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82544       };
82545     } catch (std::exception& e) {
82546       {
82547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82548       };
82549     } catch (Dali::DaliException e) {
82550       {
82551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82552       };
82553     } catch (...) {
82554       {
82555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82556       };
82557     }
82558   }
82559
82560   jresult = result;
82561   return jresult;
82562 }
82563
82564
82565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
82566   unsigned int jresult ;
82567   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82568   unsigned int result;
82569
82570   arg1 = (Dali::Toolkit::TableView *)jarg1;
82571   {
82572     try {
82573       result = (unsigned int)(arg1)->GetRows();
82574     } catch (std::out_of_range& e) {
82575       {
82576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82577       };
82578     } catch (std::exception& e) {
82579       {
82580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82581       };
82582     } catch (Dali::DaliException e) {
82583       {
82584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82585       };
82586     } catch (...) {
82587       {
82588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82589       };
82590     }
82591   }
82592
82593   jresult = result;
82594   return jresult;
82595 }
82596
82597
82598 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
82599   unsigned int jresult ;
82600   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82601   unsigned int result;
82602
82603   arg1 = (Dali::Toolkit::TableView *)jarg1;
82604   {
82605     try {
82606       result = (unsigned int)(arg1)->GetColumns();
82607     } catch (std::out_of_range& e) {
82608       {
82609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82610       };
82611     } catch (std::exception& e) {
82612       {
82613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82614       };
82615     } catch (Dali::DaliException e) {
82616       {
82617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82618       };
82619     } catch (...) {
82620       {
82621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82622       };
82623     }
82624   }
82625
82626   jresult = result;
82627   return jresult;
82628 }
82629
82630
82631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
82632   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82633   Dali::Toolkit::TableView::CellPosition arg2 ;
82634   Dali::HorizontalAlignment::Type arg3 ;
82635   Dali::VerticalAlignment::Type arg4 ;
82636   Dali::Toolkit::TableView::CellPosition *argp2 ;
82637
82638   arg1 = (Dali::Toolkit::TableView *)jarg1;
82639   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82640   if (!argp2) {
82641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82642     return ;
82643   }
82644   arg2 = *argp2;
82645   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
82646   arg4 = (Dali::VerticalAlignment::Type)jarg4;
82647   {
82648     try {
82649       (arg1)->SetCellAlignment(arg2,arg3,arg4);
82650     } catch (std::out_of_range& e) {
82651       {
82652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82653       };
82654     } catch (std::exception& e) {
82655       {
82656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82657       };
82658     } catch (Dali::DaliException e) {
82659       {
82660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82661       };
82662     } catch (...) {
82663       {
82664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82665       };
82666     }
82667   }
82668
82669 }
82670
82671
82672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
82673   unsigned int jresult ;
82674   unsigned int result;
82675
82676   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
82677   jresult = result;
82678   return jresult;
82679 }
82680
82681
82682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
82683   int jresult ;
82684   int result;
82685
82686   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
82687   jresult = (int)result;
82688   return jresult;
82689 }
82690
82691
82692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
82693   int jresult ;
82694   int result;
82695
82696   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
82697   jresult = (int)result;
82698   return jresult;
82699 }
82700
82701
82702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
82703   int jresult ;
82704   int result;
82705
82706   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
82707   jresult = (int)result;
82708   return jresult;
82709 }
82710
82711
82712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
82713   int jresult ;
82714   int result;
82715
82716   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
82717   jresult = (int)result;
82718   return jresult;
82719 }
82720
82721
82722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
82723   int jresult ;
82724   int result;
82725
82726   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
82727   jresult = (int)result;
82728   return jresult;
82729 }
82730
82731
82732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
82733   int jresult ;
82734   int result;
82735
82736   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
82737   jresult = (int)result;
82738   return jresult;
82739 }
82740
82741
82742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
82743   int jresult ;
82744   int result;
82745
82746   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
82747   jresult = (int)result;
82748   return jresult;
82749 }
82750
82751
82752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
82753   int jresult ;
82754   int result;
82755
82756   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
82757   jresult = (int)result;
82758   return jresult;
82759 }
82760
82761
82762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
82763   int jresult ;
82764   int result;
82765
82766   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
82767   jresult = (int)result;
82768   return jresult;
82769 }
82770
82771
82772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
82773   int jresult ;
82774   int result;
82775
82776   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
82777   jresult = (int)result;
82778   return jresult;
82779 }
82780
82781
82782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
82783   int jresult ;
82784   int result;
82785
82786   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
82787   jresult = (int)result;
82788   return jresult;
82789 }
82790
82791
82792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
82793   int jresult ;
82794   int result;
82795
82796   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
82797   jresult = (int)result;
82798   return jresult;
82799 }
82800
82801
82802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
82803   int jresult ;
82804   int result;
82805
82806   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
82807   jresult = (int)result;
82808   return jresult;
82809 }
82810
82811
82812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
82813   int jresult ;
82814   int result;
82815
82816   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
82817   jresult = (int)result;
82818   return jresult;
82819 }
82820
82821
82822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
82823   int jresult ;
82824   int result;
82825
82826   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
82827   jresult = (int)result;
82828   return jresult;
82829 }
82830
82831
82832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
82833   int jresult ;
82834   int result;
82835
82836   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
82837   jresult = (int)result;
82838   return jresult;
82839 }
82840
82841
82842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
82843   int jresult ;
82844   int result;
82845
82846   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
82847   jresult = (int)result;
82848   return jresult;
82849 }
82850
82851
82852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
82853   int jresult ;
82854   int result;
82855
82856   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
82857   jresult = (int)result;
82858   return jresult;
82859 }
82860
82861
82862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
82863   int jresult ;
82864   int result;
82865
82866   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
82867   jresult = (int)result;
82868   return jresult;
82869 }
82870
82871
82872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
82873   void * jresult ;
82874   Dali::Toolkit::TextLabel::Property *result = 0 ;
82875
82876   {
82877     try {
82878       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
82879     } catch (std::out_of_range& e) {
82880       {
82881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82882       };
82883     } catch (std::exception& e) {
82884       {
82885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82886       };
82887     } catch (Dali::DaliException e) {
82888       {
82889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82890       };
82891     } catch (...) {
82892       {
82893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82894       };
82895     }
82896   }
82897
82898   jresult = (void *)result;
82899   return jresult;
82900 }
82901
82902
82903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
82904   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
82905
82906   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
82907   {
82908     try {
82909       delete arg1;
82910     } catch (std::out_of_range& e) {
82911       {
82912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82913       };
82914     } catch (std::exception& e) {
82915       {
82916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82917       };
82918     } catch (Dali::DaliException e) {
82919       {
82920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82921       };
82922     } catch (...) {
82923       {
82924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82925       };
82926     }
82927   }
82928
82929 }
82930
82931
82932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
82933   void * jresult ;
82934   Dali::Toolkit::TextLabel result;
82935
82936   {
82937     try {
82938       result = Dali::Toolkit::TextLabel::New();
82939     } catch (std::out_of_range& e) {
82940       {
82941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82942       };
82943     } catch (std::exception& e) {
82944       {
82945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82946       };
82947     } catch (Dali::DaliException e) {
82948       {
82949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82950       };
82951     } catch (...) {
82952       {
82953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82954       };
82955     }
82956   }
82957
82958   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
82959   return jresult;
82960 }
82961
82962
82963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
82964   void * jresult ;
82965   std::string *arg1 = 0 ;
82966   Dali::Toolkit::TextLabel result;
82967
82968   if (!jarg1) {
82969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82970     return 0;
82971   }
82972   std::string arg1_str(jarg1);
82973   arg1 = &arg1_str;
82974   {
82975     try {
82976       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
82977     } catch (std::out_of_range& e) {
82978       {
82979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82980       };
82981     } catch (std::exception& e) {
82982       {
82983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82984       };
82985     } catch (Dali::DaliException e) {
82986       {
82987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82988       };
82989     } catch (...) {
82990       {
82991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82992       };
82993     }
82994   }
82995
82996   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
82997
82998   //argout typemap for const std::string&
82999
83000   return jresult;
83001 }
83002
83003
83004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
83005   void * jresult ;
83006   Dali::Toolkit::TextLabel *result = 0 ;
83007
83008   {
83009     try {
83010       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
83011     } catch (std::out_of_range& e) {
83012       {
83013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83014       };
83015     } catch (std::exception& e) {
83016       {
83017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83018       };
83019     } catch (Dali::DaliException e) {
83020       {
83021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83022       };
83023     } catch (...) {
83024       {
83025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83026       };
83027     }
83028   }
83029
83030   jresult = (void *)result;
83031   return jresult;
83032 }
83033
83034
83035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
83036   void * jresult ;
83037   Dali::Toolkit::TextLabel *arg1 = 0 ;
83038   Dali::Toolkit::TextLabel *result = 0 ;
83039
83040   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83041   if (!arg1) {
83042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83043     return 0;
83044   }
83045   {
83046     try {
83047       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
83048     } catch (std::out_of_range& e) {
83049       {
83050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83051       };
83052     } catch (std::exception& e) {
83053       {
83054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83055       };
83056     } catch (Dali::DaliException e) {
83057       {
83058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83059       };
83060     } catch (...) {
83061       {
83062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83063       };
83064     }
83065   }
83066
83067   jresult = (void *)result;
83068   return jresult;
83069 }
83070
83071
83072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
83073   void * jresult ;
83074   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83075   Dali::Toolkit::TextLabel *arg2 = 0 ;
83076   Dali::Toolkit::TextLabel *result = 0 ;
83077
83078   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83079   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
83080   if (!arg2) {
83081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83082     return 0;
83083   }
83084   {
83085     try {
83086       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
83087     } catch (std::out_of_range& e) {
83088       {
83089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83090       };
83091     } catch (std::exception& e) {
83092       {
83093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83094       };
83095     } catch (Dali::DaliException e) {
83096       {
83097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83098       };
83099     } catch (...) {
83100       {
83101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83102       };
83103     }
83104   }
83105
83106   jresult = (void *)result;
83107   return jresult;
83108 }
83109
83110
83111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
83112   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83113
83114   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83115   {
83116     try {
83117       delete arg1;
83118     } catch (std::out_of_range& e) {
83119       {
83120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83121       };
83122     } catch (std::exception& e) {
83123       {
83124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83125       };
83126     } catch (Dali::DaliException e) {
83127       {
83128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83129       };
83130     } catch (...) {
83131       {
83132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83133       };
83134     }
83135   }
83136
83137 }
83138
83139
83140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
83141   void * jresult ;
83142   Dali::BaseHandle arg1 ;
83143   Dali::BaseHandle *argp1 ;
83144   Dali::Toolkit::TextLabel result;
83145
83146   argp1 = (Dali::BaseHandle *)jarg1;
83147   if (!argp1) {
83148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83149     return 0;
83150   }
83151   arg1 = *argp1;
83152   {
83153     try {
83154       result = Dali::Toolkit::TextLabel::DownCast(arg1);
83155     } catch (std::out_of_range& e) {
83156       {
83157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83158       };
83159     } catch (std::exception& e) {
83160       {
83161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83162       };
83163     } catch (Dali::DaliException e) {
83164       {
83165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83166       };
83167     } catch (...) {
83168       {
83169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83170       };
83171     }
83172   }
83173
83174   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83175   return jresult;
83176 }
83177
83178
83179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
83180   void * jresult ;
83181   Dali::Toolkit::AccessibilityManager *result = 0 ;
83182
83183   {
83184     try {
83185       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
83186     } catch (std::out_of_range& e) {
83187       {
83188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83189       };
83190     } catch (std::exception& e) {
83191       {
83192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83193       };
83194     } catch (Dali::DaliException e) {
83195       {
83196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83197       };
83198     } catch (...) {
83199       {
83200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83201       };
83202     }
83203   }
83204
83205   jresult = (void *)result;
83206   return jresult;
83207 }
83208
83209
83210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
83211   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83212
83213   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83214   {
83215     try {
83216       delete arg1;
83217     } catch (std::out_of_range& e) {
83218       {
83219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83220       };
83221     } catch (std::exception& e) {
83222       {
83223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83224       };
83225     } catch (Dali::DaliException e) {
83226       {
83227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83228       };
83229     } catch (...) {
83230       {
83231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83232       };
83233     }
83234   }
83235
83236 }
83237
83238
83239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
83240   void * jresult ;
83241   Dali::Toolkit::AccessibilityManager result;
83242
83243   {
83244     try {
83245       result = Dali::Toolkit::AccessibilityManager::Get();
83246     } catch (std::out_of_range& e) {
83247       {
83248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83249       };
83250     } catch (std::exception& e) {
83251       {
83252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83253       };
83254     } catch (Dali::DaliException e) {
83255       {
83256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83257       };
83258     } catch (...) {
83259       {
83260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83261       };
83262     }
83263   }
83264
83265   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
83266   return jresult;
83267 }
83268
83269
83270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
83271   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83272   Dali::Actor arg2 ;
83273   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83274   std::string *arg4 = 0 ;
83275   Dali::Actor *argp2 ;
83276
83277   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83278   argp2 = (Dali::Actor *)jarg2;
83279   if (!argp2) {
83280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83281     return ;
83282   }
83283   arg2 = *argp2;
83284   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83285   if (!jarg4) {
83286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83287     return ;
83288   }
83289   std::string arg4_str(jarg4);
83290   arg4 = &arg4_str;
83291   {
83292     try {
83293       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
83294     } catch (std::out_of_range& e) {
83295       {
83296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83297       };
83298     } catch (std::exception& e) {
83299       {
83300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83301       };
83302     } catch (Dali::DaliException e) {
83303       {
83304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83305       };
83306     } catch (...) {
83307       {
83308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83309       };
83310     }
83311   }
83312
83313
83314   //argout typemap for const std::string&
83315
83316 }
83317
83318
83319 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
83320   char * jresult ;
83321   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83322   Dali::Actor arg2 ;
83323   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83324   Dali::Actor *argp2 ;
83325   std::string result;
83326
83327   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83328   argp2 = (Dali::Actor *)jarg2;
83329   if (!argp2) {
83330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83331     return 0;
83332   }
83333   arg2 = *argp2;
83334   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83335   {
83336     try {
83337       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
83338     } catch (std::out_of_range& e) {
83339       {
83340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83341       };
83342     } catch (std::exception& e) {
83343       {
83344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83345       };
83346     } catch (Dali::DaliException e) {
83347       {
83348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83349       };
83350     } catch (...) {
83351       {
83352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83353       };
83354     }
83355   }
83356
83357   jresult = SWIG_csharp_string_callback((&result)->c_str());
83358   return jresult;
83359 }
83360
83361
83362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
83363   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83364   Dali::Actor arg2 ;
83365   unsigned int arg3 ;
83366   Dali::Actor *argp2 ;
83367
83368   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83369   argp2 = (Dali::Actor *)jarg2;
83370   if (!argp2) {
83371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83372     return ;
83373   }
83374   arg2 = *argp2;
83375   arg3 = (unsigned int)jarg3;
83376   {
83377     try {
83378       (arg1)->SetFocusOrder(arg2,arg3);
83379     } catch (std::out_of_range& e) {
83380       {
83381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83382       };
83383     } catch (std::exception& e) {
83384       {
83385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83386       };
83387     } catch (Dali::DaliException e) {
83388       {
83389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83390       };
83391     } catch (...) {
83392       {
83393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83394       };
83395     }
83396   }
83397
83398 }
83399
83400
83401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
83402   unsigned int jresult ;
83403   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83404   Dali::Actor arg2 ;
83405   Dali::Actor *argp2 ;
83406   unsigned int result;
83407
83408   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83409   argp2 = (Dali::Actor *)jarg2;
83410   if (!argp2) {
83411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83412     return 0;
83413   }
83414   arg2 = *argp2;
83415   {
83416     try {
83417       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
83418     } catch (std::out_of_range& e) {
83419       {
83420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83421       };
83422     } catch (std::exception& e) {
83423       {
83424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83425       };
83426     } catch (Dali::DaliException e) {
83427       {
83428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83429       };
83430     } catch (...) {
83431       {
83432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83433       };
83434     }
83435   }
83436
83437   jresult = result;
83438   return jresult;
83439 }
83440
83441
83442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
83443   unsigned int jresult ;
83444   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83445   unsigned int result;
83446
83447   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83448   {
83449     try {
83450       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
83451     } catch (std::out_of_range& e) {
83452       {
83453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83454       };
83455     } catch (std::exception& e) {
83456       {
83457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83458       };
83459     } catch (Dali::DaliException e) {
83460       {
83461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83462       };
83463     } catch (...) {
83464       {
83465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83466       };
83467     }
83468   }
83469
83470   jresult = result;
83471   return jresult;
83472 }
83473
83474
83475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
83476   void * jresult ;
83477   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83478   unsigned int arg2 ;
83479   Dali::Actor result;
83480
83481   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83482   arg2 = (unsigned int)jarg2;
83483   {
83484     try {
83485       result = (arg1)->GetActorByFocusOrder(arg2);
83486     } catch (std::out_of_range& e) {
83487       {
83488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83489       };
83490     } catch (std::exception& e) {
83491       {
83492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83493       };
83494     } catch (Dali::DaliException e) {
83495       {
83496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83497       };
83498     } catch (...) {
83499       {
83500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83501       };
83502     }
83503   }
83504
83505   jresult = new Dali::Actor((const Dali::Actor &)result);
83506   return jresult;
83507 }
83508
83509
83510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
83511   unsigned int jresult ;
83512   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83513   Dali::Actor arg2 ;
83514   Dali::Actor *argp2 ;
83515   bool result;
83516
83517   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83518   argp2 = (Dali::Actor *)jarg2;
83519   if (!argp2) {
83520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83521     return 0;
83522   }
83523   arg2 = *argp2;
83524   {
83525     try {
83526       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
83527     } catch (std::out_of_range& e) {
83528       {
83529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83530       };
83531     } catch (std::exception& e) {
83532       {
83533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83534       };
83535     } catch (Dali::DaliException e) {
83536       {
83537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83538       };
83539     } catch (...) {
83540       {
83541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83542       };
83543     }
83544   }
83545
83546   jresult = result;
83547   return jresult;
83548 }
83549
83550
83551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
83552   void * jresult ;
83553   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83554   Dali::Actor result;
83555
83556   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83557   {
83558     try {
83559       result = (arg1)->GetCurrentFocusActor();
83560     } catch (std::out_of_range& e) {
83561       {
83562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83563       };
83564     } catch (std::exception& e) {
83565       {
83566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83567       };
83568     } catch (Dali::DaliException e) {
83569       {
83570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83571       };
83572     } catch (...) {
83573       {
83574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83575       };
83576     }
83577   }
83578
83579   jresult = new Dali::Actor((const Dali::Actor &)result);
83580   return jresult;
83581 }
83582
83583
83584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
83585   void * jresult ;
83586   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83587   Dali::Actor result;
83588
83589   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83590   {
83591     try {
83592       result = (arg1)->GetCurrentFocusGroup();
83593     } catch (std::out_of_range& e) {
83594       {
83595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83596       };
83597     } catch (std::exception& e) {
83598       {
83599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83600       };
83601     } catch (Dali::DaliException e) {
83602       {
83603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83604       };
83605     } catch (...) {
83606       {
83607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83608       };
83609     }
83610   }
83611
83612   jresult = new Dali::Actor((const Dali::Actor &)result);
83613   return jresult;
83614 }
83615
83616
83617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
83618   unsigned int jresult ;
83619   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83620   unsigned int result;
83621
83622   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83623   {
83624     try {
83625       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
83626     } catch (std::out_of_range& e) {
83627       {
83628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83629       };
83630     } catch (std::exception& e) {
83631       {
83632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83633       };
83634     } catch (Dali::DaliException e) {
83635       {
83636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83637       };
83638     } catch (...) {
83639       {
83640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83641       };
83642     }
83643   }
83644
83645   jresult = result;
83646   return jresult;
83647 }
83648
83649
83650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
83651   unsigned int jresult ;
83652   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83653   bool result;
83654
83655   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83656   {
83657     try {
83658       result = (bool)(arg1)->MoveFocusForward();
83659     } catch (std::out_of_range& e) {
83660       {
83661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83662       };
83663     } catch (std::exception& e) {
83664       {
83665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83666       };
83667     } catch (Dali::DaliException e) {
83668       {
83669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83670       };
83671     } catch (...) {
83672       {
83673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83674       };
83675     }
83676   }
83677
83678   jresult = result;
83679   return jresult;
83680 }
83681
83682
83683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
83684   unsigned int jresult ;
83685   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83686   bool result;
83687
83688   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83689   {
83690     try {
83691       result = (bool)(arg1)->MoveFocusBackward();
83692     } catch (std::out_of_range& e) {
83693       {
83694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83695       };
83696     } catch (std::exception& e) {
83697       {
83698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83699       };
83700     } catch (Dali::DaliException e) {
83701       {
83702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83703       };
83704     } catch (...) {
83705       {
83706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83707       };
83708     }
83709   }
83710
83711   jresult = result;
83712   return jresult;
83713 }
83714
83715
83716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
83717   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83718
83719   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83720   {
83721     try {
83722       (arg1)->ClearFocus();
83723     } catch (std::out_of_range& e) {
83724       {
83725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83726       };
83727     } catch (std::exception& e) {
83728       {
83729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83730       };
83731     } catch (Dali::DaliException e) {
83732       {
83733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83734       };
83735     } catch (...) {
83736       {
83737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83738       };
83739     }
83740   }
83741
83742 }
83743
83744
83745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
83746   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83747
83748   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83749   {
83750     try {
83751       (arg1)->Reset();
83752     } catch (std::out_of_range& e) {
83753       {
83754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83755       };
83756     } catch (std::exception& e) {
83757       {
83758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83759       };
83760     } catch (Dali::DaliException e) {
83761       {
83762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83763       };
83764     } catch (...) {
83765       {
83766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83767       };
83768     }
83769   }
83770
83771 }
83772
83773
83774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
83775   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83776   Dali::Actor arg2 ;
83777   bool arg3 ;
83778   Dali::Actor *argp2 ;
83779
83780   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83781   argp2 = (Dali::Actor *)jarg2;
83782   if (!argp2) {
83783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83784     return ;
83785   }
83786   arg2 = *argp2;
83787   arg3 = jarg3 ? true : false;
83788   {
83789     try {
83790       (arg1)->SetFocusGroup(arg2,arg3);
83791     } catch (std::out_of_range& e) {
83792       {
83793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83794       };
83795     } catch (std::exception& e) {
83796       {
83797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83798       };
83799     } catch (Dali::DaliException e) {
83800       {
83801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83802       };
83803     } catch (...) {
83804       {
83805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83806       };
83807     }
83808   }
83809
83810 }
83811
83812
83813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
83814   unsigned int jresult ;
83815   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83816   Dali::Actor arg2 ;
83817   Dali::Actor *argp2 ;
83818   bool result;
83819
83820   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83821   argp2 = (Dali::Actor *)jarg2;
83822   if (!argp2) {
83823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83824     return 0;
83825   }
83826   arg2 = *argp2;
83827   {
83828     try {
83829       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
83830     } catch (std::out_of_range& e) {
83831       {
83832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83833       };
83834     } catch (std::exception& e) {
83835       {
83836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83837       };
83838     } catch (Dali::DaliException e) {
83839       {
83840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83841       };
83842     } catch (...) {
83843       {
83844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83845       };
83846     }
83847   }
83848
83849   jresult = result;
83850   return jresult;
83851 }
83852
83853
83854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
83855   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83856   bool arg2 ;
83857
83858   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83859   arg2 = jarg2 ? true : false;
83860   {
83861     try {
83862       (arg1)->SetGroupMode(arg2);
83863     } catch (std::out_of_range& e) {
83864       {
83865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83866       };
83867     } catch (std::exception& e) {
83868       {
83869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83870       };
83871     } catch (Dali::DaliException e) {
83872       {
83873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83874       };
83875     } catch (...) {
83876       {
83877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83878       };
83879     }
83880   }
83881
83882 }
83883
83884
83885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
83886   unsigned int jresult ;
83887   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83888   bool result;
83889
83890   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83891   {
83892     try {
83893       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
83894     } catch (std::out_of_range& e) {
83895       {
83896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83897       };
83898     } catch (std::exception& e) {
83899       {
83900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83901       };
83902     } catch (Dali::DaliException e) {
83903       {
83904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83905       };
83906     } catch (...) {
83907       {
83908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83909       };
83910     }
83911   }
83912
83913   jresult = result;
83914   return jresult;
83915 }
83916
83917
83918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
83919   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83920   bool arg2 ;
83921
83922   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83923   arg2 = jarg2 ? true : false;
83924   {
83925     try {
83926       (arg1)->SetWrapMode(arg2);
83927     } catch (std::out_of_range& e) {
83928       {
83929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83930       };
83931     } catch (std::exception& e) {
83932       {
83933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83934       };
83935     } catch (Dali::DaliException e) {
83936       {
83937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83938       };
83939     } catch (...) {
83940       {
83941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83942       };
83943     }
83944   }
83945
83946 }
83947
83948
83949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
83950   unsigned int jresult ;
83951   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83952   bool result;
83953
83954   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83955   {
83956     try {
83957       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
83958     } catch (std::out_of_range& e) {
83959       {
83960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83961       };
83962     } catch (std::exception& e) {
83963       {
83964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83965       };
83966     } catch (Dali::DaliException e) {
83967       {
83968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83969       };
83970     } catch (...) {
83971       {
83972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83973       };
83974     }
83975   }
83976
83977   jresult = result;
83978   return jresult;
83979 }
83980
83981
83982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
83983   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83984   Dali::Actor arg2 ;
83985   Dali::Actor *argp2 ;
83986
83987   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83988   argp2 = (Dali::Actor *)jarg2;
83989   if (!argp2) {
83990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83991     return ;
83992   }
83993   arg2 = *argp2;
83994   {
83995     try {
83996       (arg1)->SetFocusIndicatorActor(arg2);
83997     } catch (std::out_of_range& e) {
83998       {
83999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84000       };
84001     } catch (std::exception& e) {
84002       {
84003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84004       };
84005     } catch (Dali::DaliException e) {
84006       {
84007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84008       };
84009     } catch (...) {
84010       {
84011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84012       };
84013     }
84014   }
84015
84016 }
84017
84018
84019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
84020   void * jresult ;
84021   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84022   Dali::Actor result;
84023
84024   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84025   {
84026     try {
84027       result = (arg1)->GetFocusIndicatorActor();
84028     } catch (std::out_of_range& e) {
84029       {
84030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84031       };
84032     } catch (std::exception& e) {
84033       {
84034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84035       };
84036     } catch (Dali::DaliException e) {
84037       {
84038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84039       };
84040     } catch (...) {
84041       {
84042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84043       };
84044     }
84045   }
84046
84047   jresult = new Dali::Actor((const Dali::Actor &)result);
84048   return jresult;
84049 }
84050
84051
84052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
84053   void * jresult ;
84054   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84055   Dali::Actor arg2 ;
84056   Dali::Actor *argp2 ;
84057   Dali::Actor result;
84058
84059   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84060   argp2 = (Dali::Actor *)jarg2;
84061   if (!argp2) {
84062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84063     return 0;
84064   }
84065   arg2 = *argp2;
84066   {
84067     try {
84068       result = (arg1)->GetFocusGroup(arg2);
84069     } catch (std::out_of_range& e) {
84070       {
84071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84072       };
84073     } catch (std::exception& e) {
84074       {
84075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84076       };
84077     } catch (Dali::DaliException e) {
84078       {
84079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84080       };
84081     } catch (...) {
84082       {
84083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84084       };
84085     }
84086   }
84087
84088   jresult = new Dali::Actor((const Dali::Actor &)result);
84089   return jresult;
84090 }
84091
84092
84093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
84094   void * jresult ;
84095   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84096   Dali::Vector2 result;
84097
84098   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84099   {
84100     try {
84101       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
84102     } catch (std::out_of_range& e) {
84103       {
84104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84105       };
84106     } catch (std::exception& e) {
84107       {
84108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84109       };
84110     } catch (Dali::DaliException e) {
84111       {
84112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84113       };
84114     } catch (...) {
84115       {
84116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84117       };
84118     }
84119   }
84120
84121   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
84122   return jresult;
84123 }
84124
84125
84126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
84127   void * jresult ;
84128   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84129   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
84130
84131   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84132   {
84133     try {
84134       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
84135     } catch (std::out_of_range& e) {
84136       {
84137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84138       };
84139     } catch (std::exception& e) {
84140       {
84141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84142       };
84143     } catch (Dali::DaliException e) {
84144       {
84145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84146       };
84147     } catch (...) {
84148       {
84149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84150       };
84151     }
84152   }
84153
84154   jresult = (void *)result;
84155   return jresult;
84156 }
84157
84158
84159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
84160   void * jresult ;
84161   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84162   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
84163
84164   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84165   {
84166     try {
84167       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
84168     } catch (std::out_of_range& e) {
84169       {
84170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84171       };
84172     } catch (std::exception& e) {
84173       {
84174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84175       };
84176     } catch (Dali::DaliException e) {
84177       {
84178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84179       };
84180     } catch (...) {
84181       {
84182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84183       };
84184     }
84185   }
84186
84187   jresult = (void *)result;
84188   return jresult;
84189 }
84190
84191
84192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
84193   void * jresult ;
84194   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84195   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
84196
84197   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84198   {
84199     try {
84200       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
84201     } catch (std::out_of_range& e) {
84202       {
84203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84204       };
84205     } catch (std::exception& e) {
84206       {
84207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84208       };
84209     } catch (Dali::DaliException e) {
84210       {
84211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84212       };
84213     } catch (...) {
84214       {
84215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84216       };
84217     }
84218   }
84219
84220   jresult = (void *)result;
84221   return jresult;
84222 }
84223
84224
84225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
84226   void * jresult ;
84227   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84228   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84229
84230   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84231   {
84232     try {
84233       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
84234     } catch (std::out_of_range& e) {
84235       {
84236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84237       };
84238     } catch (std::exception& e) {
84239       {
84240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84241       };
84242     } catch (Dali::DaliException e) {
84243       {
84244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84245       };
84246     } catch (...) {
84247       {
84248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84249       };
84250     }
84251   }
84252
84253   jresult = (void *)result;
84254   return jresult;
84255 }
84256
84257
84258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
84259   void * jresult ;
84260   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84261   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84262
84263   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84264   {
84265     try {
84266       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
84267     } catch (std::out_of_range& e) {
84268       {
84269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84270       };
84271     } catch (std::exception& e) {
84272       {
84273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84274       };
84275     } catch (Dali::DaliException e) {
84276       {
84277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84278       };
84279     } catch (...) {
84280       {
84281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84282       };
84283     }
84284   }
84285
84286   jresult = (void *)result;
84287   return jresult;
84288 }
84289
84290
84291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
84292   void * jresult ;
84293   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84294   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84295
84296   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84297   {
84298     try {
84299       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
84300     } catch (std::out_of_range& e) {
84301       {
84302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84303       };
84304     } catch (std::exception& e) {
84305       {
84306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84307       };
84308     } catch (Dali::DaliException e) {
84309       {
84310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84311       };
84312     } catch (...) {
84313       {
84314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84315       };
84316     }
84317   }
84318
84319   jresult = (void *)result;
84320   return jresult;
84321 }
84322
84323
84324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
84325   void * jresult ;
84326   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84327   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84328
84329   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84330   {
84331     try {
84332       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
84333     } catch (std::out_of_range& e) {
84334       {
84335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84336       };
84337     } catch (std::exception& e) {
84338       {
84339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84340       };
84341     } catch (Dali::DaliException e) {
84342       {
84343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84344       };
84345     } catch (...) {
84346       {
84347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84348       };
84349     }
84350   }
84351
84352   jresult = (void *)result;
84353   return jresult;
84354 }
84355
84356
84357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
84358   void * jresult ;
84359   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84360   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84361
84362   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84363   {
84364     try {
84365       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
84366     } catch (std::out_of_range& e) {
84367       {
84368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84369       };
84370     } catch (std::exception& e) {
84371       {
84372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84373       };
84374     } catch (Dali::DaliException e) {
84375       {
84376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84377       };
84378     } catch (...) {
84379       {
84380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84381       };
84382     }
84383   }
84384
84385   jresult = (void *)result;
84386   return jresult;
84387 }
84388
84389
84390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
84391   void * jresult ;
84392   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84393   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84394
84395   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84396   {
84397     try {
84398       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
84399     } catch (std::out_of_range& e) {
84400       {
84401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84402       };
84403     } catch (std::exception& e) {
84404       {
84405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84406       };
84407     } catch (Dali::DaliException e) {
84408       {
84409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84410       };
84411     } catch (...) {
84412       {
84413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84414       };
84415     }
84416   }
84417
84418   jresult = (void *)result;
84419   return jresult;
84420 }
84421
84422
84423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
84424   void * jresult ;
84425   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84426   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84427
84428   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84429   {
84430     try {
84431       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
84432     } catch (std::out_of_range& e) {
84433       {
84434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84435       };
84436     } catch (std::exception& e) {
84437       {
84438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84439       };
84440     } catch (Dali::DaliException e) {
84441       {
84442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84443       };
84444     } catch (...) {
84445       {
84446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84447       };
84448     }
84449   }
84450
84451   jresult = (void *)result;
84452   return jresult;
84453 }
84454
84455
84456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
84457   void * jresult ;
84458   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84459   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84460
84461   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84462   {
84463     try {
84464       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
84465     } catch (std::out_of_range& e) {
84466       {
84467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84468       };
84469     } catch (std::exception& e) {
84470       {
84471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84472       };
84473     } catch (Dali::DaliException e) {
84474       {
84475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84476       };
84477     } catch (...) {
84478       {
84479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84480       };
84481     }
84482   }
84483
84484   jresult = (void *)result;
84485   return jresult;
84486 }
84487
84488
84489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
84490   void * jresult ;
84491   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84492   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84493
84494   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84495   {
84496     try {
84497       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
84498     } catch (std::out_of_range& e) {
84499       {
84500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84501       };
84502     } catch (std::exception& e) {
84503       {
84504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84505       };
84506     } catch (Dali::DaliException e) {
84507       {
84508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84509       };
84510     } catch (...) {
84511       {
84512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84513       };
84514     }
84515   }
84516
84517   jresult = (void *)result;
84518   return jresult;
84519 }
84520
84521
84522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
84523   void * jresult ;
84524   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84525   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84526
84527   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84528   {
84529     try {
84530       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
84531     } catch (std::out_of_range& e) {
84532       {
84533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84534       };
84535     } catch (std::exception& e) {
84536       {
84537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84538       };
84539     } catch (Dali::DaliException e) {
84540       {
84541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84542       };
84543     } catch (...) {
84544       {
84545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84546       };
84547     }
84548   }
84549
84550   jresult = (void *)result;
84551   return jresult;
84552 }
84553
84554
84555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
84556   void * jresult ;
84557   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84558   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84559
84560   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84561   {
84562     try {
84563       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
84564     } catch (std::out_of_range& e) {
84565       {
84566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84567       };
84568     } catch (std::exception& e) {
84569       {
84570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84571       };
84572     } catch (Dali::DaliException e) {
84573       {
84574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84575       };
84576     } catch (...) {
84577       {
84578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84579       };
84580     }
84581   }
84582
84583   jresult = (void *)result;
84584   return jresult;
84585 }
84586
84587
84588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
84589   void * jresult ;
84590   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84591   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84592
84593   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84594   {
84595     try {
84596       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
84597     } catch (std::out_of_range& e) {
84598       {
84599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84600       };
84601     } catch (std::exception& e) {
84602       {
84603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84604       };
84605     } catch (Dali::DaliException e) {
84606       {
84607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84608       };
84609     } catch (...) {
84610       {
84611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84612       };
84613     }
84614   }
84615
84616   jresult = (void *)result;
84617   return jresult;
84618 }
84619
84620
84621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
84622   void * jresult ;
84623   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84624   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84625
84626   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84627   {
84628     try {
84629       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
84630     } catch (std::out_of_range& e) {
84631       {
84632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84633       };
84634     } catch (std::exception& e) {
84635       {
84636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84637       };
84638     } catch (Dali::DaliException e) {
84639       {
84640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84641       };
84642     } catch (...) {
84643       {
84644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84645       };
84646     }
84647   }
84648
84649   jresult = (void *)result;
84650   return jresult;
84651 }
84652
84653
84654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
84655   void * jresult ;
84656   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84657   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84658
84659   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84660   {
84661     try {
84662       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
84663     } catch (std::out_of_range& e) {
84664       {
84665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84666       };
84667     } catch (std::exception& e) {
84668       {
84669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84670       };
84671     } catch (Dali::DaliException e) {
84672       {
84673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84674       };
84675     } catch (...) {
84676       {
84677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84678       };
84679     }
84680   }
84681
84682   jresult = (void *)result;
84683   return jresult;
84684 }
84685
84686
84687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
84688   void * jresult ;
84689   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84690   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84691
84692   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84693   {
84694     try {
84695       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
84696     } catch (std::out_of_range& e) {
84697       {
84698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84699       };
84700     } catch (std::exception& e) {
84701       {
84702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84703       };
84704     } catch (Dali::DaliException e) {
84705       {
84706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84707       };
84708     } catch (...) {
84709       {
84710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84711       };
84712     }
84713   }
84714
84715   jresult = (void *)result;
84716   return jresult;
84717 }
84718
84719
84720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
84721   void * jresult ;
84722   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84723   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84724
84725   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84726   {
84727     try {
84728       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
84729     } catch (std::out_of_range& e) {
84730       {
84731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84732       };
84733     } catch (std::exception& e) {
84734       {
84735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84736       };
84737     } catch (Dali::DaliException e) {
84738       {
84739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84740       };
84741     } catch (...) {
84742       {
84743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84744       };
84745     }
84746   }
84747
84748   jresult = (void *)result;
84749   return jresult;
84750 }
84751
84752
84753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
84754   void * jresult ;
84755   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84756   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84757
84758   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84759   {
84760     try {
84761       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
84762     } catch (std::out_of_range& e) {
84763       {
84764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84765       };
84766     } catch (std::exception& e) {
84767       {
84768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84769       };
84770     } catch (Dali::DaliException e) {
84771       {
84772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84773       };
84774     } catch (...) {
84775       {
84776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84777       };
84778     }
84779   }
84780
84781   jresult = (void *)result;
84782   return jresult;
84783 }
84784
84785
84786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
84787   void * jresult ;
84788   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84789   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84790
84791   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84792   {
84793     try {
84794       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
84795     } catch (std::out_of_range& e) {
84796       {
84797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84798       };
84799     } catch (std::exception& e) {
84800       {
84801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84802       };
84803     } catch (Dali::DaliException e) {
84804       {
84805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84806       };
84807     } catch (...) {
84808       {
84809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84810       };
84811     }
84812   }
84813
84814   jresult = (void *)result;
84815   return jresult;
84816 }
84817
84818
84819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
84820   void * jresult ;
84821   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84822   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84823
84824   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84825   {
84826     try {
84827       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
84828     } catch (std::out_of_range& e) {
84829       {
84830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84831       };
84832     } catch (std::exception& e) {
84833       {
84834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84835       };
84836     } catch (Dali::DaliException e) {
84837       {
84838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84839       };
84840     } catch (...) {
84841       {
84842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84843       };
84844     }
84845   }
84846
84847   jresult = (void *)result;
84848   return jresult;
84849 }
84850
84851
84852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
84853   void * jresult ;
84854   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84855   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84856
84857   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84858   {
84859     try {
84860       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
84861     } catch (std::out_of_range& e) {
84862       {
84863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84864       };
84865     } catch (std::exception& e) {
84866       {
84867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84868       };
84869     } catch (Dali::DaliException e) {
84870       {
84871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84872       };
84873     } catch (...) {
84874       {
84875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84876       };
84877     }
84878   }
84879
84880   jresult = (void *)result;
84881   return jresult;
84882 }
84883
84884
84885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
84886   void * jresult ;
84887   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84888   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84889
84890   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84891   {
84892     try {
84893       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
84894     } catch (std::out_of_range& e) {
84895       {
84896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84897       };
84898     } catch (std::exception& e) {
84899       {
84900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84901       };
84902     } catch (Dali::DaliException e) {
84903       {
84904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84905       };
84906     } catch (...) {
84907       {
84908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84909       };
84910     }
84911   }
84912
84913   jresult = (void *)result;
84914   return jresult;
84915 }
84916
84917
84918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
84919   void * jresult ;
84920   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84921   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84922
84923   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84924   {
84925     try {
84926       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
84927     } catch (std::out_of_range& e) {
84928       {
84929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84930       };
84931     } catch (std::exception& e) {
84932       {
84933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84934       };
84935     } catch (Dali::DaliException e) {
84936       {
84937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84938       };
84939     } catch (...) {
84940       {
84941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84942       };
84943     }
84944   }
84945
84946   jresult = (void *)result;
84947   return jresult;
84948 }
84949
84950
84951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
84952   void * jresult ;
84953   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84954   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84955
84956   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84957   {
84958     try {
84959       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
84960     } catch (std::out_of_range& e) {
84961       {
84962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84963       };
84964     } catch (std::exception& e) {
84965       {
84966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84967       };
84968     } catch (Dali::DaliException e) {
84969       {
84970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84971       };
84972     } catch (...) {
84973       {
84974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84975       };
84976     }
84977   }
84978
84979   jresult = (void *)result;
84980   return jresult;
84981 }
84982
84983
84984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
84985   void * jresult ;
84986   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84987   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84988
84989   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84990   {
84991     try {
84992       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
84993     } catch (std::out_of_range& e) {
84994       {
84995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84996       };
84997     } catch (std::exception& e) {
84998       {
84999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85000       };
85001     } catch (Dali::DaliException e) {
85002       {
85003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85004       };
85005     } catch (...) {
85006       {
85007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85008       };
85009     }
85010   }
85011
85012   jresult = (void *)result;
85013   return jresult;
85014 }
85015
85016
85017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
85018   void * jresult ;
85019   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85020   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85021
85022   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85023   {
85024     try {
85025       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
85026     } catch (std::out_of_range& e) {
85027       {
85028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85029       };
85030     } catch (std::exception& e) {
85031       {
85032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85033       };
85034     } catch (Dali::DaliException e) {
85035       {
85036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85037       };
85038     } catch (...) {
85039       {
85040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85041       };
85042     }
85043   }
85044
85045   jresult = (void *)result;
85046   return jresult;
85047 }
85048
85049
85050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
85051   void * jresult ;
85052   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85053   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85054
85055   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85056   {
85057     try {
85058       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
85059     } catch (std::out_of_range& e) {
85060       {
85061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85062       };
85063     } catch (std::exception& e) {
85064       {
85065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85066       };
85067     } catch (Dali::DaliException e) {
85068       {
85069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85070       };
85071     } catch (...) {
85072       {
85073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85074       };
85075     }
85076   }
85077
85078   jresult = (void *)result;
85079   return jresult;
85080 }
85081
85082
85083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
85084   void * jresult ;
85085   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85086   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
85087
85088   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85089   {
85090     try {
85091       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
85092     } catch (std::out_of_range& e) {
85093       {
85094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85095       };
85096     } catch (std::exception& e) {
85097       {
85098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85099       };
85100     } catch (Dali::DaliException e) {
85101       {
85102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85103       };
85104     } catch (...) {
85105       {
85106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85107       };
85108     }
85109   }
85110
85111   jresult = (void *)result;
85112   return jresult;
85113 }
85114
85115
85116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
85117   void * jresult ;
85118   Dali::Toolkit::StyleManager *result = 0 ;
85119
85120   {
85121     try {
85122       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
85123     } catch (std::out_of_range& e) {
85124       {
85125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85126       };
85127     } catch (std::exception& e) {
85128       {
85129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85130       };
85131     } catch (Dali::DaliException e) {
85132       {
85133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85134       };
85135     } catch (...) {
85136       {
85137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85138       };
85139     }
85140   }
85141
85142   jresult = (void *)result;
85143   return jresult;
85144 }
85145
85146
85147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
85148   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85149
85150   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85151   {
85152     try {
85153       delete arg1;
85154     } catch (std::out_of_range& e) {
85155       {
85156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85157       };
85158     } catch (std::exception& e) {
85159       {
85160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85161       };
85162     } catch (Dali::DaliException e) {
85163       {
85164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85165       };
85166     } catch (...) {
85167       {
85168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85169       };
85170     }
85171   }
85172
85173 }
85174
85175
85176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
85177   void * jresult ;
85178   Dali::Toolkit::StyleManager result;
85179
85180   {
85181     try {
85182       result = Dali::Toolkit::StyleManager::Get();
85183     } catch (std::out_of_range& e) {
85184       {
85185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85186       };
85187     } catch (std::exception& e) {
85188       {
85189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85190       };
85191     } catch (Dali::DaliException e) {
85192       {
85193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85194       };
85195     } catch (...) {
85196       {
85197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85198       };
85199     }
85200   }
85201
85202   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
85203   return jresult;
85204 }
85205
85206
85207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
85208   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85209   std::string *arg2 = 0 ;
85210
85211   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85212   if (!jarg2) {
85213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85214     return ;
85215   }
85216   std::string arg2_str(jarg2);
85217   arg2 = &arg2_str;
85218   {
85219     try {
85220       (arg1)->ApplyTheme((std::string const &)*arg2);
85221     } catch (std::out_of_range& e) {
85222       {
85223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85224       };
85225     } catch (std::exception& e) {
85226       {
85227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85228       };
85229     } catch (Dali::DaliException e) {
85230       {
85231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85232       };
85233     } catch (...) {
85234       {
85235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85236       };
85237     }
85238   }
85239
85240
85241   //argout typemap for const std::string&
85242
85243 }
85244
85245
85246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
85247   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85248
85249   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85250   {
85251     try {
85252       (arg1)->ApplyDefaultTheme();
85253     } catch (std::out_of_range& e) {
85254       {
85255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85256       };
85257     } catch (std::exception& e) {
85258       {
85259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85260       };
85261     } catch (Dali::DaliException e) {
85262       {
85263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85264       };
85265     } catch (...) {
85266       {
85267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85268       };
85269     }
85270   }
85271
85272 }
85273
85274
85275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85276   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85277   std::string *arg2 = 0 ;
85278   Dali::Property::Value *arg3 = 0 ;
85279
85280   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85281   if (!jarg2) {
85282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85283     return ;
85284   }
85285   std::string arg2_str(jarg2);
85286   arg2 = &arg2_str;
85287   arg3 = (Dali::Property::Value *)jarg3;
85288   if (!arg3) {
85289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
85290     return ;
85291   }
85292   {
85293     try {
85294       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
85295     } catch (std::out_of_range& e) {
85296       {
85297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85298       };
85299     } catch (std::exception& e) {
85300       {
85301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85302       };
85303     } catch (Dali::DaliException e) {
85304       {
85305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85306       };
85307     } catch (...) {
85308       {
85309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85310       };
85311     }
85312   }
85313
85314
85315   //argout typemap for const std::string&
85316
85317 }
85318
85319
85320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85321   unsigned int jresult ;
85322   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85323   std::string *arg2 = 0 ;
85324   Dali::Property::Value *arg3 = 0 ;
85325   bool result;
85326
85327   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85328   if (!jarg2) {
85329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85330     return 0;
85331   }
85332   std::string arg2_str(jarg2);
85333   arg2 = &arg2_str;
85334   arg3 = (Dali::Property::Value *)jarg3;
85335   if (!arg3) {
85336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
85337     return 0;
85338   }
85339   {
85340     try {
85341       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
85342     } catch (std::out_of_range& e) {
85343       {
85344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85345       };
85346     } catch (std::exception& e) {
85347       {
85348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85349       };
85350     } catch (Dali::DaliException e) {
85351       {
85352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85353       };
85354     } catch (...) {
85355       {
85356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85357       };
85358     }
85359   }
85360
85361   jresult = result;
85362
85363   //argout typemap for const std::string&
85364
85365   return jresult;
85366 }
85367
85368
85369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
85370   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85371   Dali::Toolkit::Control arg2 ;
85372   std::string *arg3 = 0 ;
85373   std::string *arg4 = 0 ;
85374   Dali::Toolkit::Control *argp2 ;
85375
85376   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85377   argp2 = (Dali::Toolkit::Control *)jarg2;
85378   if (!argp2) {
85379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
85380     return ;
85381   }
85382   arg2 = *argp2;
85383   if (!jarg3) {
85384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85385     return ;
85386   }
85387   std::string arg3_str(jarg3);
85388   arg3 = &arg3_str;
85389   if (!jarg4) {
85390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85391     return ;
85392   }
85393   std::string arg4_str(jarg4);
85394   arg4 = &arg4_str;
85395   {
85396     try {
85397       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
85398     } catch (std::out_of_range& e) {
85399       {
85400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85401       };
85402     } catch (std::exception& e) {
85403       {
85404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85405       };
85406     } catch (Dali::DaliException e) {
85407       {
85408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85409       };
85410     } catch (...) {
85411       {
85412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85413       };
85414     }
85415   }
85416
85417
85418   //argout typemap for const std::string&
85419
85420
85421   //argout typemap for const std::string&
85422
85423 }
85424
85425
85426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
85427   void * jresult ;
85428   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85429   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
85430
85431   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85432   {
85433     try {
85434       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
85435     } catch (std::out_of_range& e) {
85436       {
85437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85438       };
85439     } catch (std::exception& e) {
85440       {
85441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85442       };
85443     } catch (Dali::DaliException e) {
85444       {
85445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85446       };
85447     } catch (...) {
85448       {
85449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85450       };
85451     }
85452   }
85453
85454   jresult = (void *)result;
85455   return jresult;
85456 }
85457
85458
85459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
85460   int jresult ;
85461   int result;
85462
85463   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
85464   jresult = (int)result;
85465   return jresult;
85466 }
85467
85468
85469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
85470   int jresult ;
85471   int result;
85472
85473   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
85474   jresult = (int)result;
85475   return jresult;
85476 }
85477
85478
85479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
85480   int jresult ;
85481   int result;
85482
85483   result = (int)Dali::Toolkit::Slider::Property::VALUE;
85484   jresult = (int)result;
85485   return jresult;
85486 }
85487
85488
85489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
85490   int jresult ;
85491   int result;
85492
85493   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
85494   jresult = (int)result;
85495   return jresult;
85496 }
85497
85498
85499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
85500   int jresult ;
85501   int result;
85502
85503   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
85504   jresult = (int)result;
85505   return jresult;
85506 }
85507
85508
85509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
85510   int jresult ;
85511   int result;
85512
85513   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
85514   jresult = (int)result;
85515   return jresult;
85516 }
85517
85518
85519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
85520   int jresult ;
85521   int result;
85522
85523   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
85524   jresult = (int)result;
85525   return jresult;
85526 }
85527
85528
85529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
85530   int jresult ;
85531   int result;
85532
85533   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
85534   jresult = (int)result;
85535   return jresult;
85536 }
85537
85538
85539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
85540   int jresult ;
85541   int result;
85542
85543   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
85544   jresult = (int)result;
85545   return jresult;
85546 }
85547
85548
85549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
85550   int jresult ;
85551   int result;
85552
85553   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
85554   jresult = (int)result;
85555   return jresult;
85556 }
85557
85558
85559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
85560   int jresult ;
85561   int result;
85562
85563   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
85564   jresult = (int)result;
85565   return jresult;
85566 }
85567
85568
85569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
85570   int jresult ;
85571   int result;
85572
85573   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
85574   jresult = (int)result;
85575   return jresult;
85576 }
85577
85578
85579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
85580   int jresult ;
85581   int result;
85582
85583   result = (int)Dali::Toolkit::Slider::Property::MARKS;
85584   jresult = (int)result;
85585   return jresult;
85586 }
85587
85588
85589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
85590   int jresult ;
85591   int result;
85592
85593   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
85594   jresult = (int)result;
85595   return jresult;
85596 }
85597
85598
85599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
85600   int jresult ;
85601   int result;
85602
85603   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
85604   jresult = (int)result;
85605   return jresult;
85606 }
85607
85608
85609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
85610   void * jresult ;
85611   Dali::Toolkit::Slider::Property *result = 0 ;
85612
85613   {
85614     try {
85615       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
85616     } catch (std::out_of_range& e) {
85617       {
85618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85619       };
85620     } catch (std::exception& e) {
85621       {
85622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85623       };
85624     } catch (Dali::DaliException e) {
85625       {
85626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85627       };
85628     } catch (...) {
85629       {
85630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85631       };
85632     }
85633   }
85634
85635   jresult = (void *)result;
85636   return jresult;
85637 }
85638
85639
85640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
85641   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
85642
85643   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
85644   {
85645     try {
85646       delete arg1;
85647     } catch (std::out_of_range& e) {
85648       {
85649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85650       };
85651     } catch (std::exception& e) {
85652       {
85653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85654       };
85655     } catch (Dali::DaliException e) {
85656       {
85657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85658       };
85659     } catch (...) {
85660       {
85661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85662       };
85663     }
85664   }
85665
85666 }
85667
85668
85669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
85670   void * jresult ;
85671   Dali::Toolkit::Slider result;
85672
85673   {
85674     try {
85675       result = Dali::Toolkit::Slider::New();
85676     } catch (std::out_of_range& e) {
85677       {
85678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85679       };
85680     } catch (std::exception& e) {
85681       {
85682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85683       };
85684     } catch (Dali::DaliException e) {
85685       {
85686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85687       };
85688     } catch (...) {
85689       {
85690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85691       };
85692     }
85693   }
85694
85695   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85696   return jresult;
85697 }
85698
85699
85700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
85701   void * jresult ;
85702   Dali::Toolkit::Slider *result = 0 ;
85703
85704   {
85705     try {
85706       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
85707     } catch (std::out_of_range& e) {
85708       {
85709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85710       };
85711     } catch (std::exception& e) {
85712       {
85713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85714       };
85715     } catch (Dali::DaliException e) {
85716       {
85717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85718       };
85719     } catch (...) {
85720       {
85721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85722       };
85723     }
85724   }
85725
85726   jresult = (void *)result;
85727   return jresult;
85728 }
85729
85730
85731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
85732   void * jresult ;
85733   Dali::Toolkit::Slider *arg1 = 0 ;
85734   Dali::Toolkit::Slider *result = 0 ;
85735
85736   arg1 = (Dali::Toolkit::Slider *)jarg1;
85737   if (!arg1) {
85738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85739     return 0;
85740   }
85741   {
85742     try {
85743       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
85744     } catch (std::out_of_range& e) {
85745       {
85746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85747       };
85748     } catch (std::exception& e) {
85749       {
85750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85751       };
85752     } catch (Dali::DaliException e) {
85753       {
85754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85755       };
85756     } catch (...) {
85757       {
85758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85759       };
85760     }
85761   }
85762
85763   jresult = (void *)result;
85764   return jresult;
85765 }
85766
85767
85768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
85769   void * jresult ;
85770   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85771   Dali::Toolkit::Slider *arg2 = 0 ;
85772   Dali::Toolkit::Slider *result = 0 ;
85773
85774   arg1 = (Dali::Toolkit::Slider *)jarg1;
85775   arg2 = (Dali::Toolkit::Slider *)jarg2;
85776   if (!arg2) {
85777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85778     return 0;
85779   }
85780   {
85781     try {
85782       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
85783     } catch (std::out_of_range& e) {
85784       {
85785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85786       };
85787     } catch (std::exception& e) {
85788       {
85789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85790       };
85791     } catch (Dali::DaliException e) {
85792       {
85793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85794       };
85795     } catch (...) {
85796       {
85797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85798       };
85799     }
85800   }
85801
85802   jresult = (void *)result;
85803   return jresult;
85804 }
85805
85806
85807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
85808   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85809
85810   arg1 = (Dali::Toolkit::Slider *)jarg1;
85811   {
85812     try {
85813       delete arg1;
85814     } catch (std::out_of_range& e) {
85815       {
85816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85817       };
85818     } catch (std::exception& e) {
85819       {
85820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85821       };
85822     } catch (Dali::DaliException e) {
85823       {
85824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85825       };
85826     } catch (...) {
85827       {
85828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85829       };
85830     }
85831   }
85832
85833 }
85834
85835
85836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
85837   void * jresult ;
85838   Dali::BaseHandle arg1 ;
85839   Dali::BaseHandle *argp1 ;
85840   Dali::Toolkit::Slider result;
85841
85842   argp1 = (Dali::BaseHandle *)jarg1;
85843   if (!argp1) {
85844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85845     return 0;
85846   }
85847   arg1 = *argp1;
85848   {
85849     try {
85850       result = Dali::Toolkit::Slider::DownCast(arg1);
85851     } catch (std::out_of_range& e) {
85852       {
85853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85854       };
85855     } catch (std::exception& e) {
85856       {
85857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85858       };
85859     } catch (Dali::DaliException e) {
85860       {
85861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85862       };
85863     } catch (...) {
85864       {
85865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85866       };
85867     }
85868   }
85869
85870   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85871   return jresult;
85872 }
85873
85874
85875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
85876   void * jresult ;
85877   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85878   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85879
85880   arg1 = (Dali::Toolkit::Slider *)jarg1;
85881   {
85882     try {
85883       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
85884     } catch (std::out_of_range& e) {
85885       {
85886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85887       };
85888     } catch (std::exception& e) {
85889       {
85890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85891       };
85892     } catch (Dali::DaliException e) {
85893       {
85894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85895       };
85896     } catch (...) {
85897       {
85898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85899       };
85900     }
85901   }
85902
85903   jresult = (void *)result;
85904   return jresult;
85905 }
85906
85907
85908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
85909   void * jresult ;
85910   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85911   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85912
85913   arg1 = (Dali::Toolkit::Slider *)jarg1;
85914   {
85915     try {
85916       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
85917     } catch (std::out_of_range& e) {
85918       {
85919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85920       };
85921     } catch (std::exception& e) {
85922       {
85923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85924       };
85925     } catch (Dali::DaliException e) {
85926       {
85927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85928       };
85929     } catch (...) {
85930       {
85931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85932       };
85933     }
85934   }
85935
85936   jresult = (void *)result;
85937   return jresult;
85938 }
85939
85940
85941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
85942   void * jresult ;
85943   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85944   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
85945
85946   arg1 = (Dali::Toolkit::Slider *)jarg1;
85947   {
85948     try {
85949       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
85950     } catch (std::out_of_range& e) {
85951       {
85952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85953       };
85954     } catch (std::exception& e) {
85955       {
85956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85957       };
85958     } catch (Dali::DaliException e) {
85959       {
85960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85961       };
85962     } catch (...) {
85963       {
85964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85965       };
85966     }
85967   }
85968
85969   jresult = (void *)result;
85970   return jresult;
85971 }
85972
85973
85974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
85975   int jresult ;
85976   int result;
85977
85978   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
85979   jresult = (int)result;
85980   return jresult;
85981 }
85982
85983
85984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
85985   int jresult ;
85986   int result;
85987
85988   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
85989   jresult = (int)result;
85990   return jresult;
85991 }
85992
85993
85994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
85995   int jresult ;
85996   int result;
85997
85998   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
85999   jresult = (int)result;
86000   return jresult;
86001 }
86002
86003
86004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
86005   int jresult ;
86006   int result;
86007
86008   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
86009   jresult = (int)result;
86010   return jresult;
86011 }
86012
86013
86014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
86015   int result;
86016
86017   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
86018
86019   return result;
86020 }
86021
86022
86023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
86024   void * jresult ;
86025   Dali::Toolkit::VideoView::Property *result = 0 ;
86026
86027   {
86028     try {
86029       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
86030     } catch (std::out_of_range& e) {
86031       {
86032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86033       };
86034     } catch (std::exception& e) {
86035       {
86036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86037       };
86038     } catch (Dali::DaliException e) {
86039       {
86040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86041       };
86042     } catch (...) {
86043       {
86044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86045       };
86046     }
86047   }
86048
86049   jresult = (void *)result;
86050   return jresult;
86051 }
86052
86053
86054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
86055   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
86056
86057   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
86058   {
86059     try {
86060       delete arg1;
86061     } catch (std::out_of_range& e) {
86062       {
86063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86064       };
86065     } catch (std::exception& e) {
86066       {
86067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86068       };
86069     } catch (Dali::DaliException e) {
86070       {
86071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86072       };
86073     } catch (...) {
86074       {
86075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86076       };
86077     }
86078   }
86079
86080 }
86081
86082
86083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
86084   void * jresult ;
86085   Dali::Toolkit::VideoView result;
86086
86087   {
86088     try {
86089       result = Dali::Toolkit::VideoView::New();
86090     } catch (std::out_of_range& e) {
86091       {
86092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86093       };
86094     } catch (std::exception& e) {
86095       {
86096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86097       };
86098     } catch (Dali::DaliException e) {
86099       {
86100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86101       };
86102     } catch (...) {
86103       {
86104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86105       };
86106     }
86107   }
86108
86109   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86110   return jresult;
86111 }
86112
86113
86114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
86115   void * jresult ;
86116   std::string *arg1 = 0 ;
86117   Dali::Toolkit::VideoView result;
86118
86119   if (!jarg1) {
86120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86121     return 0;
86122   }
86123   std::string arg1_str(jarg1);
86124   arg1 = &arg1_str;
86125   {
86126     try {
86127       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
86128     } catch (std::out_of_range& e) {
86129       {
86130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86131       };
86132     } catch (std::exception& e) {
86133       {
86134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86135       };
86136     } catch (Dali::DaliException e) {
86137       {
86138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86139       };
86140     } catch (...) {
86141       {
86142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86143       };
86144     }
86145   }
86146
86147   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86148
86149   //argout typemap for const std::string&
86150
86151   return jresult;
86152 }
86153
86154
86155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
86156   void * jresult ;
86157   Dali::Toolkit::VideoView *result = 0 ;
86158
86159   {
86160     try {
86161       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
86162     } catch (std::out_of_range& e) {
86163       {
86164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86165       };
86166     } catch (std::exception& e) {
86167       {
86168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86169       };
86170     } catch (Dali::DaliException e) {
86171       {
86172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86173       };
86174     } catch (...) {
86175       {
86176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86177       };
86178     }
86179   }
86180
86181   jresult = (void *)result;
86182   return jresult;
86183 }
86184
86185
86186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
86187   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86188
86189   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86190   {
86191     try {
86192       delete arg1;
86193     } catch (std::out_of_range& e) {
86194       {
86195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86196       };
86197     } catch (std::exception& e) {
86198       {
86199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86200       };
86201     } catch (Dali::DaliException e) {
86202       {
86203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86204       };
86205     } catch (...) {
86206       {
86207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86208       };
86209     }
86210   }
86211
86212 }
86213
86214
86215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
86216   void * jresult ;
86217   Dali::Toolkit::VideoView *arg1 = 0 ;
86218   Dali::Toolkit::VideoView *result = 0 ;
86219
86220   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86221   if (!arg1) {
86222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86223     return 0;
86224   }
86225   {
86226     try {
86227       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
86228     } catch (std::out_of_range& e) {
86229       {
86230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86231       };
86232     } catch (std::exception& e) {
86233       {
86234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86235       };
86236     } catch (Dali::DaliException e) {
86237       {
86238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86239       };
86240     } catch (...) {
86241       {
86242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86243       };
86244     }
86245   }
86246
86247   jresult = (void *)result;
86248   return jresult;
86249 }
86250
86251
86252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
86253   void * jresult ;
86254   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86255   Dali::Toolkit::VideoView *arg2 = 0 ;
86256   Dali::Toolkit::VideoView *result = 0 ;
86257
86258   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86259   arg2 = (Dali::Toolkit::VideoView *)jarg2;
86260   if (!arg2) {
86261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86262     return 0;
86263   }
86264   {
86265     try {
86266       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
86267     } catch (std::out_of_range& e) {
86268       {
86269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86270       };
86271     } catch (std::exception& e) {
86272       {
86273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86274       };
86275     } catch (Dali::DaliException e) {
86276       {
86277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86278       };
86279     } catch (...) {
86280       {
86281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86282       };
86283     }
86284   }
86285
86286   jresult = (void *)result;
86287   return jresult;
86288 }
86289
86290
86291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
86292   void * jresult ;
86293   Dali::BaseHandle arg1 ;
86294   Dali::BaseHandle *argp1 ;
86295   Dali::Toolkit::VideoView result;
86296
86297   argp1 = (Dali::BaseHandle *)jarg1;
86298   if (!argp1) {
86299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86300     return 0;
86301   }
86302   arg1 = *argp1;
86303   {
86304     try {
86305       result = Dali::Toolkit::VideoView::DownCast(arg1);
86306     } catch (std::out_of_range& e) {
86307       {
86308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86309       };
86310     } catch (std::exception& e) {
86311       {
86312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86313       };
86314     } catch (Dali::DaliException e) {
86315       {
86316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86317       };
86318     } catch (...) {
86319       {
86320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86321       };
86322     }
86323   }
86324
86325   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86326   return jresult;
86327 }
86328
86329
86330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
86331   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86332
86333   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86334   {
86335     try {
86336       (arg1)->Play();
86337     } catch (std::out_of_range& e) {
86338       {
86339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86340       };
86341     } catch (std::exception& e) {
86342       {
86343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86344       };
86345     } catch (Dali::DaliException e) {
86346       {
86347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86348       };
86349     } catch (...) {
86350       {
86351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86352       };
86353     }
86354   }
86355
86356 }
86357
86358
86359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
86360   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86361
86362   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86363   {
86364     try {
86365       (arg1)->Pause();
86366     } catch (std::out_of_range& e) {
86367       {
86368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86369       };
86370     } catch (std::exception& e) {
86371       {
86372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86373       };
86374     } catch (Dali::DaliException e) {
86375       {
86376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86377       };
86378     } catch (...) {
86379       {
86380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86381       };
86382     }
86383   }
86384
86385 }
86386
86387
86388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
86389   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86390
86391   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86392   {
86393     try {
86394       (arg1)->Stop();
86395     } catch (std::out_of_range& e) {
86396       {
86397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86398       };
86399     } catch (std::exception& e) {
86400       {
86401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86402       };
86403     } catch (Dali::DaliException e) {
86404       {
86405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86406       };
86407     } catch (...) {
86408       {
86409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86410       };
86411     }
86412   }
86413
86414 }
86415
86416
86417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
86418   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86419   int arg2 ;
86420
86421   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86422   arg2 = (int)jarg2;
86423   {
86424     try {
86425       (arg1)->Forward(arg2);
86426     } catch (std::out_of_range& e) {
86427       {
86428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86429       };
86430     } catch (std::exception& e) {
86431       {
86432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86433       };
86434     } catch (Dali::DaliException e) {
86435       {
86436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86437       };
86438     } catch (...) {
86439       {
86440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86441       };
86442     }
86443   }
86444
86445 }
86446
86447
86448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
86449   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86450   int arg2 ;
86451
86452   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86453   arg2 = (int)jarg2;
86454   {
86455     try {
86456       (arg1)->Backward(arg2);
86457     } catch (std::out_of_range& e) {
86458       {
86459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86460       };
86461     } catch (std::exception& e) {
86462       {
86463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86464       };
86465     } catch (Dali::DaliException e) {
86466       {
86467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86468       };
86469     } catch (...) {
86470       {
86471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86472       };
86473     }
86474   }
86475
86476 }
86477
86478
86479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
86480   void * jresult ;
86481   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86482   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
86483
86484   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86485   {
86486     try {
86487       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
86488     } catch (std::out_of_range& e) {
86489       {
86490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86491       };
86492     } catch (std::exception& e) {
86493       {
86494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86495       };
86496     } catch (Dali::DaliException e) {
86497       {
86498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86499       };
86500     } catch (...) {
86501       {
86502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86503       };
86504     }
86505   }
86506
86507   jresult = (void *)result;
86508   return jresult;
86509 }
86510
86511
86512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
86513   int jresult ;
86514   int result;
86515
86516   result = (int)Dali::Toolkit::Popup::Property::TITLE;
86517   jresult = (int)result;
86518   return jresult;
86519 }
86520
86521
86522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
86523   int jresult ;
86524   int result;
86525
86526   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
86527   jresult = (int)result;
86528   return jresult;
86529 }
86530
86531
86532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
86533   int jresult ;
86534   int result;
86535
86536   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
86537   jresult = (int)result;
86538   return jresult;
86539 }
86540
86541
86542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
86543   int jresult ;
86544   int result;
86545
86546   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
86547   jresult = (int)result;
86548   return jresult;
86549 }
86550
86551
86552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
86553   int jresult ;
86554   int result;
86555
86556   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
86557   jresult = (int)result;
86558   return jresult;
86559 }
86560
86561
86562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
86563   int jresult ;
86564   int result;
86565
86566   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
86567   jresult = (int)result;
86568   return jresult;
86569 }
86570
86571
86572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
86573   int jresult ;
86574   int result;
86575
86576   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
86577   jresult = (int)result;
86578   return jresult;
86579 }
86580
86581
86582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
86583   int jresult ;
86584   int result;
86585
86586   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
86587   jresult = (int)result;
86588   return jresult;
86589 }
86590
86591
86592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
86593   int jresult ;
86594   int result;
86595
86596   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
86597   jresult = (int)result;
86598   return jresult;
86599 }
86600
86601
86602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
86603   int jresult ;
86604   int result;
86605
86606   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
86607   jresult = (int)result;
86608   return jresult;
86609 }
86610
86611
86612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
86613   int jresult ;
86614   int result;
86615
86616   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
86617   jresult = (int)result;
86618   return jresult;
86619 }
86620
86621
86622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
86623   int jresult ;
86624   int result;
86625
86626   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
86627   jresult = (int)result;
86628   return jresult;
86629 }
86630
86631
86632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
86633   int jresult ;
86634   int result;
86635
86636   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
86637   jresult = (int)result;
86638   return jresult;
86639 }
86640
86641
86642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
86643   int jresult ;
86644   int result;
86645
86646   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
86647   jresult = (int)result;
86648   return jresult;
86649 }
86650
86651
86652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
86653   int jresult ;
86654   int result;
86655
86656   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
86657   jresult = (int)result;
86658   return jresult;
86659 }
86660
86661
86662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
86663   int jresult ;
86664   int result;
86665
86666   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
86667   jresult = (int)result;
86668   return jresult;
86669 }
86670
86671
86672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
86673   int jresult ;
86674   int result;
86675
86676   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
86677   jresult = (int)result;
86678   return jresult;
86679 }
86680
86681
86682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
86683   int jresult ;
86684   int result;
86685
86686   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
86687   jresult = (int)result;
86688   return jresult;
86689 }
86690
86691
86692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
86693   int jresult ;
86694   int result;
86695
86696   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
86697   jresult = (int)result;
86698   return jresult;
86699 }
86700
86701
86702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
86703   int jresult ;
86704   int result;
86705
86706   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
86707   jresult = (int)result;
86708   return jresult;
86709 }
86710
86711
86712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
86713   int jresult ;
86714   int result;
86715
86716   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
86717   jresult = (int)result;
86718   return jresult;
86719 }
86720
86721
86722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
86723   void * jresult ;
86724   Dali::Toolkit::Popup::Property *result = 0 ;
86725
86726   {
86727     try {
86728       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
86729     } catch (std::out_of_range& e) {
86730       {
86731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86732       };
86733     } catch (std::exception& e) {
86734       {
86735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86736       };
86737     } catch (Dali::DaliException e) {
86738       {
86739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86740       };
86741     } catch (...) {
86742       {
86743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86744       };
86745     }
86746   }
86747
86748   jresult = (void *)result;
86749   return jresult;
86750 }
86751
86752
86753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
86754   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
86755
86756   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
86757   {
86758     try {
86759       delete arg1;
86760     } catch (std::out_of_range& e) {
86761       {
86762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86763       };
86764     } catch (std::exception& e) {
86765       {
86766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86767       };
86768     } catch (Dali::DaliException e) {
86769       {
86770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86771       };
86772     } catch (...) {
86773       {
86774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86775       };
86776     }
86777   }
86778
86779 }
86780
86781
86782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
86783   void * jresult ;
86784   Dali::Toolkit::Popup *result = 0 ;
86785
86786   {
86787     try {
86788       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
86789     } catch (std::out_of_range& e) {
86790       {
86791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86792       };
86793     } catch (std::exception& e) {
86794       {
86795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86796       };
86797     } catch (Dali::DaliException e) {
86798       {
86799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86800       };
86801     } catch (...) {
86802       {
86803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86804       };
86805     }
86806   }
86807
86808   jresult = (void *)result;
86809   return jresult;
86810 }
86811
86812
86813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
86814   void * jresult ;
86815   Dali::Toolkit::Popup result;
86816
86817   {
86818     try {
86819       result = Dali::Toolkit::Popup::New();
86820     } catch (std::out_of_range& e) {
86821       {
86822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86823       };
86824     } catch (std::exception& e) {
86825       {
86826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86827       };
86828     } catch (Dali::DaliException e) {
86829       {
86830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86831       };
86832     } catch (...) {
86833       {
86834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86835       };
86836     }
86837   }
86838
86839   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
86840   return jresult;
86841 }
86842
86843
86844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
86845   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86846
86847   arg1 = (Dali::Toolkit::Popup *)jarg1;
86848   {
86849     try {
86850       delete arg1;
86851     } catch (std::out_of_range& e) {
86852       {
86853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86854       };
86855     } catch (std::exception& e) {
86856       {
86857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86858       };
86859     } catch (Dali::DaliException e) {
86860       {
86861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86862       };
86863     } catch (...) {
86864       {
86865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86866       };
86867     }
86868   }
86869
86870 }
86871
86872
86873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
86874   void * jresult ;
86875   Dali::Toolkit::Popup *arg1 = 0 ;
86876   Dali::Toolkit::Popup *result = 0 ;
86877
86878   arg1 = (Dali::Toolkit::Popup *)jarg1;
86879   if (!arg1) {
86880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
86881     return 0;
86882   }
86883   {
86884     try {
86885       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
86886     } catch (std::out_of_range& e) {
86887       {
86888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86889       };
86890     } catch (std::exception& e) {
86891       {
86892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86893       };
86894     } catch (Dali::DaliException e) {
86895       {
86896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86897       };
86898     } catch (...) {
86899       {
86900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86901       };
86902     }
86903   }
86904
86905   jresult = (void *)result;
86906   return jresult;
86907 }
86908
86909
86910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
86911   void * jresult ;
86912   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86913   Dali::Toolkit::Popup *arg2 = 0 ;
86914   Dali::Toolkit::Popup *result = 0 ;
86915
86916   arg1 = (Dali::Toolkit::Popup *)jarg1;
86917   arg2 = (Dali::Toolkit::Popup *)jarg2;
86918   if (!arg2) {
86919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
86920     return 0;
86921   }
86922   {
86923     try {
86924       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
86925     } catch (std::out_of_range& e) {
86926       {
86927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86928       };
86929     } catch (std::exception& e) {
86930       {
86931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86932       };
86933     } catch (Dali::DaliException e) {
86934       {
86935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86936       };
86937     } catch (...) {
86938       {
86939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86940       };
86941     }
86942   }
86943
86944   jresult = (void *)result;
86945   return jresult;
86946 }
86947
86948
86949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
86950   void * jresult ;
86951   Dali::BaseHandle arg1 ;
86952   Dali::BaseHandle *argp1 ;
86953   Dali::Toolkit::Popup result;
86954
86955   argp1 = (Dali::BaseHandle *)jarg1;
86956   if (!argp1) {
86957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86958     return 0;
86959   }
86960   arg1 = *argp1;
86961   {
86962     try {
86963       result = Dali::Toolkit::Popup::DownCast(arg1);
86964     } catch (std::out_of_range& e) {
86965       {
86966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86967       };
86968     } catch (std::exception& e) {
86969       {
86970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86971       };
86972     } catch (Dali::DaliException e) {
86973       {
86974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86975       };
86976     } catch (...) {
86977       {
86978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86979       };
86980     }
86981   }
86982
86983   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
86984   return jresult;
86985 }
86986
86987
86988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
86989   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86990   Dali::Actor arg2 ;
86991   Dali::Actor *argp2 ;
86992
86993   arg1 = (Dali::Toolkit::Popup *)jarg1;
86994   argp2 = (Dali::Actor *)jarg2;
86995   if (!argp2) {
86996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86997     return ;
86998   }
86999   arg2 = *argp2;
87000   {
87001     try {
87002       (arg1)->SetTitle(arg2);
87003     } catch (std::out_of_range& e) {
87004       {
87005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87006       };
87007     } catch (std::exception& e) {
87008       {
87009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87010       };
87011     } catch (Dali::DaliException e) {
87012       {
87013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87014       };
87015     } catch (...) {
87016       {
87017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87018       };
87019     }
87020   }
87021
87022 }
87023
87024
87025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
87026   void * jresult ;
87027   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87028   Dali::Actor result;
87029
87030   arg1 = (Dali::Toolkit::Popup *)jarg1;
87031   {
87032     try {
87033       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
87034     } catch (std::out_of_range& e) {
87035       {
87036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87037       };
87038     } catch (std::exception& e) {
87039       {
87040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87041       };
87042     } catch (Dali::DaliException e) {
87043       {
87044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87045       };
87046     } catch (...) {
87047       {
87048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87049       };
87050     }
87051   }
87052
87053   jresult = new Dali::Actor((const Dali::Actor &)result);
87054   return jresult;
87055 }
87056
87057
87058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
87059   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87060   Dali::Actor arg2 ;
87061   Dali::Actor *argp2 ;
87062
87063   arg1 = (Dali::Toolkit::Popup *)jarg1;
87064   argp2 = (Dali::Actor *)jarg2;
87065   if (!argp2) {
87066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87067     return ;
87068   }
87069   arg2 = *argp2;
87070   {
87071     try {
87072       (arg1)->SetContent(arg2);
87073     } catch (std::out_of_range& e) {
87074       {
87075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87076       };
87077     } catch (std::exception& e) {
87078       {
87079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87080       };
87081     } catch (Dali::DaliException e) {
87082       {
87083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87084       };
87085     } catch (...) {
87086       {
87087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87088       };
87089     }
87090   }
87091
87092 }
87093
87094
87095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
87096   void * jresult ;
87097   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87098   Dali::Actor result;
87099
87100   arg1 = (Dali::Toolkit::Popup *)jarg1;
87101   {
87102     try {
87103       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
87104     } catch (std::out_of_range& e) {
87105       {
87106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87107       };
87108     } catch (std::exception& e) {
87109       {
87110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87111       };
87112     } catch (Dali::DaliException e) {
87113       {
87114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87115       };
87116     } catch (...) {
87117       {
87118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87119       };
87120     }
87121   }
87122
87123   jresult = new Dali::Actor((const Dali::Actor &)result);
87124   return jresult;
87125 }
87126
87127
87128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
87129   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87130   Dali::Actor arg2 ;
87131   Dali::Actor *argp2 ;
87132
87133   arg1 = (Dali::Toolkit::Popup *)jarg1;
87134   argp2 = (Dali::Actor *)jarg2;
87135   if (!argp2) {
87136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87137     return ;
87138   }
87139   arg2 = *argp2;
87140   {
87141     try {
87142       (arg1)->SetFooter(arg2);
87143     } catch (std::out_of_range& e) {
87144       {
87145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87146       };
87147     } catch (std::exception& e) {
87148       {
87149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87150       };
87151     } catch (Dali::DaliException e) {
87152       {
87153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87154       };
87155     } catch (...) {
87156       {
87157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87158       };
87159     }
87160   }
87161
87162 }
87163
87164
87165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
87166   void * jresult ;
87167   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87168   Dali::Actor result;
87169
87170   arg1 = (Dali::Toolkit::Popup *)jarg1;
87171   {
87172     try {
87173       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
87174     } catch (std::out_of_range& e) {
87175       {
87176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87177       };
87178     } catch (std::exception& e) {
87179       {
87180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87181       };
87182     } catch (Dali::DaliException e) {
87183       {
87184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87185       };
87186     } catch (...) {
87187       {
87188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87189       };
87190     }
87191   }
87192
87193   jresult = new Dali::Actor((const Dali::Actor &)result);
87194   return jresult;
87195 }
87196
87197
87198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
87199   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87200   Dali::Toolkit::Popup::DisplayState arg2 ;
87201
87202   arg1 = (Dali::Toolkit::Popup *)jarg1;
87203   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
87204   {
87205     try {
87206       (arg1)->SetDisplayState(arg2);
87207     } catch (std::out_of_range& e) {
87208       {
87209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87210       };
87211     } catch (std::exception& e) {
87212       {
87213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87214       };
87215     } catch (Dali::DaliException e) {
87216       {
87217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87218       };
87219     } catch (...) {
87220       {
87221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87222       };
87223     }
87224   }
87225
87226 }
87227
87228
87229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
87230   int jresult ;
87231   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87232   Dali::Toolkit::Popup::DisplayState result;
87233
87234   arg1 = (Dali::Toolkit::Popup *)jarg1;
87235   {
87236     try {
87237       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
87238     } catch (std::out_of_range& e) {
87239       {
87240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87241       };
87242     } catch (std::exception& e) {
87243       {
87244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87245       };
87246     } catch (Dali::DaliException e) {
87247       {
87248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87249       };
87250     } catch (...) {
87251       {
87252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87253       };
87254     }
87255   }
87256
87257   jresult = (int)result;
87258   return jresult;
87259 }
87260
87261
87262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
87263   void * jresult ;
87264   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87265   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
87266
87267   arg1 = (Dali::Toolkit::Popup *)jarg1;
87268   {
87269     try {
87270       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
87271     } catch (std::out_of_range& e) {
87272       {
87273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87274       };
87275     } catch (std::exception& e) {
87276       {
87277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87278       };
87279     } catch (Dali::DaliException e) {
87280       {
87281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87282       };
87283     } catch (...) {
87284       {
87285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87286       };
87287     }
87288   }
87289
87290   jresult = (void *)result;
87291   return jresult;
87292 }
87293
87294
87295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
87296   void * jresult ;
87297   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87298   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87299
87300   arg1 = (Dali::Toolkit::Popup *)jarg1;
87301   {
87302     try {
87303       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
87304     } catch (std::out_of_range& e) {
87305       {
87306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87307       };
87308     } catch (std::exception& e) {
87309       {
87310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87311       };
87312     } catch (Dali::DaliException e) {
87313       {
87314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87315       };
87316     } catch (...) {
87317       {
87318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87319       };
87320     }
87321   }
87322
87323   jresult = (void *)result;
87324   return jresult;
87325 }
87326
87327
87328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
87329   void * jresult ;
87330   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87331   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87332
87333   arg1 = (Dali::Toolkit::Popup *)jarg1;
87334   {
87335     try {
87336       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
87337     } catch (std::out_of_range& e) {
87338       {
87339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87340       };
87341     } catch (std::exception& e) {
87342       {
87343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87344       };
87345     } catch (Dali::DaliException e) {
87346       {
87347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87348       };
87349     } catch (...) {
87350       {
87351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87352       };
87353     }
87354   }
87355
87356   jresult = (void *)result;
87357   return jresult;
87358 }
87359
87360
87361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
87362   void * jresult ;
87363   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87364   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87365
87366   arg1 = (Dali::Toolkit::Popup *)jarg1;
87367   {
87368     try {
87369       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
87370     } catch (std::out_of_range& e) {
87371       {
87372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87373       };
87374     } catch (std::exception& e) {
87375       {
87376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87377       };
87378     } catch (Dali::DaliException e) {
87379       {
87380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87381       };
87382     } catch (...) {
87383       {
87384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87385       };
87386     }
87387   }
87388
87389   jresult = (void *)result;
87390   return jresult;
87391 }
87392
87393
87394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
87395   void * jresult ;
87396   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87397   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87398
87399   arg1 = (Dali::Toolkit::Popup *)jarg1;
87400   {
87401     try {
87402       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
87403     } catch (std::out_of_range& e) {
87404       {
87405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87406       };
87407     } catch (std::exception& e) {
87408       {
87409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87410       };
87411     } catch (Dali::DaliException e) {
87412       {
87413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87414       };
87415     } catch (...) {
87416       {
87417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87418       };
87419     }
87420   }
87421
87422   jresult = (void *)result;
87423   return jresult;
87424 }
87425
87426
87427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
87428   int jresult ;
87429   int result;
87430
87431   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
87432   jresult = (int)result;
87433   return jresult;
87434 }
87435
87436
87437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
87438   int jresult ;
87439   int result;
87440
87441   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
87442   jresult = (int)result;
87443   return jresult;
87444 }
87445
87446
87447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
87448   int jresult ;
87449   int result;
87450
87451   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
87452   jresult = (int)result;
87453   return jresult;
87454 }
87455
87456
87457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
87458   int jresult ;
87459   int result;
87460
87461   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
87462   jresult = (int)result;
87463   return jresult;
87464 }
87465
87466
87467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
87468   int jresult ;
87469   int result;
87470
87471   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
87472   jresult = (int)result;
87473   return jresult;
87474 }
87475
87476
87477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
87478   int jresult ;
87479   int result;
87480
87481   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
87482   jresult = (int)result;
87483   return jresult;
87484 }
87485
87486
87487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
87488   int jresult ;
87489   int result;
87490
87491   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
87492   jresult = (int)result;
87493   return jresult;
87494 }
87495
87496
87497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
87498   int jresult ;
87499   int result;
87500
87501   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
87502   jresult = (int)result;
87503   return jresult;
87504 }
87505
87506
87507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
87508   int jresult ;
87509   int result;
87510
87511   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
87512   jresult = (int)result;
87513   return jresult;
87514 }
87515
87516
87517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
87518   void * jresult ;
87519   Dali::Toolkit::ProgressBar::Property *result = 0 ;
87520
87521   {
87522     try {
87523       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
87524     } catch (std::out_of_range& e) {
87525       {
87526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87527       };
87528     } catch (std::exception& e) {
87529       {
87530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87531       };
87532     } catch (Dali::DaliException e) {
87533       {
87534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87535       };
87536     } catch (...) {
87537       {
87538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87539       };
87540     }
87541   }
87542
87543   jresult = (void *)result;
87544   return jresult;
87545 }
87546
87547
87548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
87549   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
87550
87551   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
87552   {
87553     try {
87554       delete arg1;
87555     } catch (std::out_of_range& e) {
87556       {
87557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87558       };
87559     } catch (std::exception& e) {
87560       {
87561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87562       };
87563     } catch (Dali::DaliException e) {
87564       {
87565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87566       };
87567     } catch (...) {
87568       {
87569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87570       };
87571     }
87572   }
87573
87574 }
87575
87576
87577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
87578   void * jresult ;
87579   Dali::Toolkit::ProgressBar result;
87580
87581   {
87582     try {
87583       result = Dali::Toolkit::ProgressBar::New();
87584     } catch (std::out_of_range& e) {
87585       {
87586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87587       };
87588     } catch (std::exception& e) {
87589       {
87590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87591       };
87592     } catch (Dali::DaliException e) {
87593       {
87594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87595       };
87596     } catch (...) {
87597       {
87598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87599       };
87600     }
87601   }
87602
87603   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87604   return jresult;
87605 }
87606
87607
87608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
87609   void * jresult ;
87610   Dali::Toolkit::ProgressBar *result = 0 ;
87611
87612   {
87613     try {
87614       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
87615     } catch (std::out_of_range& e) {
87616       {
87617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87618       };
87619     } catch (std::exception& e) {
87620       {
87621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87622       };
87623     } catch (Dali::DaliException e) {
87624       {
87625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87626       };
87627     } catch (...) {
87628       {
87629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87630       };
87631     }
87632   }
87633
87634   jresult = (void *)result;
87635   return jresult;
87636 }
87637
87638
87639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
87640   void * jresult ;
87641   Dali::Toolkit::ProgressBar *arg1 = 0 ;
87642   Dali::Toolkit::ProgressBar *result = 0 ;
87643
87644   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87645   if (!arg1) {
87646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87647     return 0;
87648   }
87649   {
87650     try {
87651       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
87652     } catch (std::out_of_range& e) {
87653       {
87654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87655       };
87656     } catch (std::exception& e) {
87657       {
87658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87659       };
87660     } catch (Dali::DaliException e) {
87661       {
87662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87663       };
87664     } catch (...) {
87665       {
87666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87667       };
87668     }
87669   }
87670
87671   jresult = (void *)result;
87672   return jresult;
87673 }
87674
87675
87676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
87677   void * jresult ;
87678   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87679   Dali::Toolkit::ProgressBar *arg2 = 0 ;
87680   Dali::Toolkit::ProgressBar *result = 0 ;
87681
87682   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87683   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
87684   if (!arg2) {
87685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87686     return 0;
87687   }
87688   {
87689     try {
87690       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
87691     } catch (std::out_of_range& e) {
87692       {
87693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87694       };
87695     } catch (std::exception& e) {
87696       {
87697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87698       };
87699     } catch (Dali::DaliException e) {
87700       {
87701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87702       };
87703     } catch (...) {
87704       {
87705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87706       };
87707     }
87708   }
87709
87710   jresult = (void *)result;
87711   return jresult;
87712 }
87713
87714
87715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
87716   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87717
87718   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87719   {
87720     try {
87721       delete arg1;
87722     } catch (std::out_of_range& e) {
87723       {
87724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87725       };
87726     } catch (std::exception& e) {
87727       {
87728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87729       };
87730     } catch (Dali::DaliException e) {
87731       {
87732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87733       };
87734     } catch (...) {
87735       {
87736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87737       };
87738     }
87739   }
87740
87741 }
87742
87743
87744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
87745   void * jresult ;
87746   Dali::BaseHandle arg1 ;
87747   Dali::BaseHandle *argp1 ;
87748   Dali::Toolkit::ProgressBar result;
87749
87750   argp1 = (Dali::BaseHandle *)jarg1;
87751   if (!argp1) {
87752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87753     return 0;
87754   }
87755   arg1 = *argp1;
87756   {
87757     try {
87758       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
87759     } catch (std::out_of_range& e) {
87760       {
87761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87762       };
87763     } catch (std::exception& e) {
87764       {
87765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87766       };
87767     } catch (Dali::DaliException e) {
87768       {
87769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87770       };
87771     } catch (...) {
87772       {
87773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87774       };
87775     }
87776   }
87777
87778   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87779   return jresult;
87780 }
87781
87782
87783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
87784   void * jresult ;
87785   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87786   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
87787
87788   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87789   {
87790     try {
87791       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87792     } catch (std::out_of_range& e) {
87793       {
87794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87795       };
87796     } catch (std::exception& e) {
87797       {
87798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87799       };
87800     } catch (Dali::DaliException e) {
87801       {
87802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87803       };
87804     } catch (...) {
87805       {
87806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87807       };
87808     }
87809   }
87810
87811   jresult = (void *)result;
87812   return jresult;
87813 }
87814
87815
87816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
87817   void * jresult ;
87818   Dali::Toolkit::GaussianBlurView *result = 0 ;
87819
87820   {
87821     try {
87822       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
87823     } catch (std::out_of_range& e) {
87824       {
87825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87826       };
87827     } catch (std::exception& e) {
87828       {
87829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87830       };
87831     } catch (Dali::DaliException e) {
87832       {
87833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87834       };
87835     } catch (...) {
87836       {
87837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87838       };
87839     }
87840   }
87841
87842   jresult = (void *)result;
87843   return jresult;
87844 }
87845
87846
87847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
87848   void * jresult ;
87849   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
87850   Dali::Toolkit::GaussianBlurView *result = 0 ;
87851
87852   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87853   if (!arg1) {
87854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
87855     return 0;
87856   }
87857   {
87858     try {
87859       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView 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_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
87885   void * jresult ;
87886   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87887   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
87888   Dali::Toolkit::GaussianBlurView *result = 0 ;
87889
87890   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87891   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
87892   if (!arg2) {
87893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
87894     return 0;
87895   }
87896   {
87897     try {
87898       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView 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_delete_GaussianBlurView(void * jarg1) {
87924   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87925
87926   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87927   {
87928     try {
87929       delete arg1;
87930     } catch (std::out_of_range& e) {
87931       {
87932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87933       };
87934     } catch (std::exception& e) {
87935       {
87936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87937       };
87938     } catch (Dali::DaliException e) {
87939       {
87940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87941       };
87942     } catch (...) {
87943       {
87944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87945       };
87946     }
87947   }
87948
87949 }
87950
87951
87952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
87953   void * jresult ;
87954   Dali::BaseHandle arg1 ;
87955   Dali::BaseHandle *argp1 ;
87956   Dali::Toolkit::GaussianBlurView result;
87957
87958   argp1 = (Dali::BaseHandle *)jarg1;
87959   if (!argp1) {
87960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87961     return 0;
87962   }
87963   arg1 = *argp1;
87964   {
87965     try {
87966       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
87967     } catch (std::out_of_range& e) {
87968       {
87969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87970       };
87971     } catch (std::exception& e) {
87972       {
87973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87974       };
87975     } catch (Dali::DaliException e) {
87976       {
87977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87978       };
87979     } catch (...) {
87980       {
87981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87982       };
87983     }
87984   }
87985
87986   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
87987   return jresult;
87988 }
87989
87990
87991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
87992   void * jresult ;
87993   Dali::Toolkit::GaussianBlurView result;
87994
87995   {
87996     try {
87997       result = Dali::Toolkit::GaussianBlurView::New();
87998     } catch (std::out_of_range& e) {
87999       {
88000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88001       };
88002     } catch (std::exception& e) {
88003       {
88004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88005       };
88006     } catch (Dali::DaliException e) {
88007       {
88008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88009       };
88010     } catch (...) {
88011       {
88012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88013       };
88014     }
88015   }
88016
88017   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88018   return jresult;
88019 }
88020
88021
88022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
88023   void * jresult ;
88024   unsigned int arg1 ;
88025   float arg2 ;
88026   Dali::Pixel::Format arg3 ;
88027   float arg4 ;
88028   float arg5 ;
88029   bool arg6 ;
88030   Dali::Toolkit::GaussianBlurView result;
88031
88032   arg1 = (unsigned int)jarg1;
88033   arg2 = (float)jarg2;
88034   arg3 = (Dali::Pixel::Format)jarg3;
88035   arg4 = (float)jarg4;
88036   arg5 = (float)jarg5;
88037   arg6 = jarg6 ? true : false;
88038   {
88039     try {
88040       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
88041     } catch (std::out_of_range& e) {
88042       {
88043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88044       };
88045     } catch (std::exception& e) {
88046       {
88047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88048       };
88049     } catch (Dali::DaliException e) {
88050       {
88051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88052       };
88053     } catch (...) {
88054       {
88055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88056       };
88057     }
88058   }
88059
88060   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88061   return jresult;
88062 }
88063
88064
88065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
88066   void * jresult ;
88067   unsigned int arg1 ;
88068   float arg2 ;
88069   Dali::Pixel::Format arg3 ;
88070   float arg4 ;
88071   float arg5 ;
88072   Dali::Toolkit::GaussianBlurView result;
88073
88074   arg1 = (unsigned int)jarg1;
88075   arg2 = (float)jarg2;
88076   arg3 = (Dali::Pixel::Format)jarg3;
88077   arg4 = (float)jarg4;
88078   arg5 = (float)jarg5;
88079   {
88080     try {
88081       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
88082     } catch (std::out_of_range& e) {
88083       {
88084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88085       };
88086     } catch (std::exception& e) {
88087       {
88088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88089       };
88090     } catch (Dali::DaliException e) {
88091       {
88092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88093       };
88094     } catch (...) {
88095       {
88096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88097       };
88098     }
88099   }
88100
88101   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88102   return jresult;
88103 }
88104
88105
88106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
88107   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88108   Dali::Actor arg2 ;
88109   Dali::Actor *argp2 ;
88110
88111   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88112   argp2 = (Dali::Actor *)jarg2;
88113   if (!argp2) {
88114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88115     return ;
88116   }
88117   arg2 = *argp2;
88118   {
88119     try {
88120       (arg1)->Add(arg2);
88121     } catch (std::out_of_range& e) {
88122       {
88123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88124       };
88125     } catch (std::exception& e) {
88126       {
88127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88128       };
88129     } catch (Dali::DaliException e) {
88130       {
88131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88132       };
88133     } catch (...) {
88134       {
88135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88136       };
88137     }
88138   }
88139
88140 }
88141
88142
88143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
88144   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88145   Dali::Actor arg2 ;
88146   Dali::Actor *argp2 ;
88147
88148   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88149   argp2 = (Dali::Actor *)jarg2;
88150   if (!argp2) {
88151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88152     return ;
88153   }
88154   arg2 = *argp2;
88155   {
88156     try {
88157       (arg1)->Remove(arg2);
88158     } catch (std::out_of_range& e) {
88159       {
88160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88161       };
88162     } catch (std::exception& e) {
88163       {
88164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88165       };
88166     } catch (Dali::DaliException e) {
88167       {
88168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88169       };
88170     } catch (...) {
88171       {
88172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88173       };
88174     }
88175   }
88176
88177 }
88178
88179
88180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
88181   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88182
88183   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88184   {
88185     try {
88186       (arg1)->Activate();
88187     } catch (std::out_of_range& e) {
88188       {
88189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88190       };
88191     } catch (std::exception& e) {
88192       {
88193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88194       };
88195     } catch (Dali::DaliException e) {
88196       {
88197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88198       };
88199     } catch (...) {
88200       {
88201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88202       };
88203     }
88204   }
88205
88206 }
88207
88208
88209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
88210   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88211
88212   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88213   {
88214     try {
88215       (arg1)->ActivateOnce();
88216     } catch (std::out_of_range& e) {
88217       {
88218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88219       };
88220     } catch (std::exception& e) {
88221       {
88222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88223       };
88224     } catch (Dali::DaliException e) {
88225       {
88226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88227       };
88228     } catch (...) {
88229       {
88230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88231       };
88232     }
88233   }
88234
88235 }
88236
88237
88238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
88239   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88240
88241   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88242   {
88243     try {
88244       (arg1)->Deactivate();
88245     } catch (std::out_of_range& e) {
88246       {
88247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88248       };
88249     } catch (std::exception& e) {
88250       {
88251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88252       };
88253     } catch (Dali::DaliException e) {
88254       {
88255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88256       };
88257     } catch (...) {
88258       {
88259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88260       };
88261     }
88262   }
88263
88264 }
88265
88266
88267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
88268   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88269   Dali::Texture arg2 ;
88270   Dali::FrameBuffer arg3 ;
88271   Dali::Texture *argp2 ;
88272   Dali::FrameBuffer *argp3 ;
88273
88274   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88275   argp2 = (Dali::Texture *)jarg2;
88276   if (!argp2) {
88277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
88278     return ;
88279   }
88280   arg2 = *argp2;
88281   argp3 = (Dali::FrameBuffer *)jarg3;
88282   if (!argp3) {
88283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
88284     return ;
88285   }
88286   arg3 = *argp3;
88287   {
88288     try {
88289       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
88290     } catch (std::out_of_range& e) {
88291       {
88292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88293       };
88294     } catch (std::exception& e) {
88295       {
88296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88297       };
88298     } catch (Dali::DaliException e) {
88299       {
88300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88301       };
88302     } catch (...) {
88303       {
88304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88305       };
88306     }
88307   }
88308
88309 }
88310
88311
88312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
88313   int jresult ;
88314   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88315   Dali::Property::Index result;
88316
88317   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88318   {
88319     try {
88320       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
88321     } catch (std::out_of_range& e) {
88322       {
88323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88324       };
88325     } catch (std::exception& e) {
88326       {
88327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88328       };
88329     } catch (Dali::DaliException e) {
88330       {
88331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88332       };
88333     } catch (...) {
88334       {
88335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88336       };
88337     }
88338   }
88339
88340   jresult = result;
88341   return jresult;
88342 }
88343
88344
88345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
88346   void * jresult ;
88347   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88348   Dali::FrameBuffer result;
88349
88350   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88351   {
88352     try {
88353       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
88354     } catch (std::out_of_range& e) {
88355       {
88356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88357       };
88358     } catch (std::exception& e) {
88359       {
88360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88361       };
88362     } catch (Dali::DaliException e) {
88363       {
88364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88365       };
88366     } catch (...) {
88367       {
88368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88369       };
88370     }
88371   }
88372
88373   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
88374   return jresult;
88375 }
88376
88377
88378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
88379   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88380   Dali::Vector4 *arg2 = 0 ;
88381
88382   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88383   arg2 = (Dali::Vector4 *)jarg2;
88384   if (!arg2) {
88385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
88386     return ;
88387   }
88388   {
88389     try {
88390       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
88391     } catch (std::out_of_range& e) {
88392       {
88393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88394       };
88395     } catch (std::exception& e) {
88396       {
88397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88398       };
88399     } catch (Dali::DaliException e) {
88400       {
88401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88402       };
88403     } catch (...) {
88404       {
88405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88406       };
88407     }
88408   }
88409
88410 }
88411
88412
88413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
88414   void * jresult ;
88415   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88416   Dali::Vector4 result;
88417
88418   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88419   {
88420     try {
88421       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
88422     } catch (std::out_of_range& e) {
88423       {
88424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88425       };
88426     } catch (std::exception& e) {
88427       {
88428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88429       };
88430     } catch (Dali::DaliException e) {
88431       {
88432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88433       };
88434     } catch (...) {
88435       {
88436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88437       };
88438     }
88439   }
88440
88441   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
88442   return jresult;
88443 }
88444
88445
88446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
88447   void * jresult ;
88448   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88449   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
88450
88451   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88452   {
88453     try {
88454       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
88455     } catch (std::out_of_range& e) {
88456       {
88457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88458       };
88459     } catch (std::exception& e) {
88460       {
88461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88462       };
88463     } catch (Dali::DaliException e) {
88464       {
88465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88466       };
88467     } catch (...) {
88468       {
88469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88470       };
88471     }
88472   }
88473
88474   jresult = (void *)result;
88475   return jresult;
88476 }
88477
88478
88479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
88480   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88481
88482   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88483   {
88484     try {
88485       delete arg1;
88486     } catch (std::out_of_range& e) {
88487       {
88488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88489       };
88490     } catch (std::exception& e) {
88491       {
88492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88493       };
88494     } catch (Dali::DaliException e) {
88495       {
88496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88497       };
88498     } catch (...) {
88499       {
88500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88501       };
88502     }
88503   }
88504
88505 }
88506
88507
88508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
88509   unsigned int jresult ;
88510   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88511   unsigned int result;
88512
88513   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88514   {
88515     try {
88516       result = (unsigned int)(arg1)->GetNumberOfPages();
88517     } catch (std::out_of_range& e) {
88518       {
88519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88520       };
88521     } catch (std::exception& e) {
88522       {
88523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88524       };
88525     } catch (Dali::DaliException e) {
88526       {
88527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88528       };
88529     } catch (...) {
88530       {
88531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88532       };
88533     }
88534   }
88535
88536   jresult = result;
88537   return jresult;
88538 }
88539
88540
88541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
88542   void * jresult ;
88543   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88544   unsigned int arg2 ;
88545   Dali::Texture result;
88546
88547   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88548   arg2 = (unsigned int)jarg2;
88549   {
88550     try {
88551       result = (arg1)->NewPage(arg2);
88552     } catch (std::out_of_range& e) {
88553       {
88554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88555       };
88556     } catch (std::exception& e) {
88557       {
88558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88559       };
88560     } catch (Dali::DaliException e) {
88561       {
88562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88563       };
88564     } catch (...) {
88565       {
88566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88567       };
88568     }
88569   }
88570
88571   jresult = new Dali::Texture((const Dali::Texture &)result);
88572   return jresult;
88573 }
88574
88575
88576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
88577   int jresult ;
88578   int result;
88579
88580   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
88581   jresult = (int)result;
88582   return jresult;
88583 }
88584
88585
88586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
88587   int jresult ;
88588   int result;
88589
88590   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
88591   jresult = (int)result;
88592   return jresult;
88593 }
88594
88595
88596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
88597   int jresult ;
88598   int result;
88599
88600   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
88601   jresult = (int)result;
88602   return jresult;
88603 }
88604
88605
88606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
88607   void * jresult ;
88608   Dali::Toolkit::PageTurnView::Property *result = 0 ;
88609
88610   {
88611     try {
88612       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
88613     } catch (std::out_of_range& e) {
88614       {
88615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88616       };
88617     } catch (std::exception& e) {
88618       {
88619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88620       };
88621     } catch (Dali::DaliException e) {
88622       {
88623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88624       };
88625     } catch (...) {
88626       {
88627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88628       };
88629     }
88630   }
88631
88632   jresult = (void *)result;
88633   return jresult;
88634 }
88635
88636
88637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
88638   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
88639
88640   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
88641   {
88642     try {
88643       delete arg1;
88644     } catch (std::out_of_range& e) {
88645       {
88646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88647       };
88648     } catch (std::exception& e) {
88649       {
88650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88651       };
88652     } catch (Dali::DaliException e) {
88653       {
88654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88655       };
88656     } catch (...) {
88657       {
88658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88659       };
88660     }
88661   }
88662
88663 }
88664
88665
88666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
88667   void * jresult ;
88668   Dali::Toolkit::PageTurnView *result = 0 ;
88669
88670   {
88671     try {
88672       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
88673     } catch (std::out_of_range& e) {
88674       {
88675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88676       };
88677     } catch (std::exception& e) {
88678       {
88679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88680       };
88681     } catch (Dali::DaliException e) {
88682       {
88683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88684       };
88685     } catch (...) {
88686       {
88687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88688       };
88689     }
88690   }
88691
88692   jresult = (void *)result;
88693   return jresult;
88694 }
88695
88696
88697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
88698   void * jresult ;
88699   Dali::Toolkit::PageTurnView *arg1 = 0 ;
88700   Dali::Toolkit::PageTurnView *result = 0 ;
88701
88702   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88703   if (!arg1) {
88704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88705     return 0;
88706   }
88707   {
88708     try {
88709       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
88710     } catch (std::out_of_range& e) {
88711       {
88712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88713       };
88714     } catch (std::exception& e) {
88715       {
88716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88717       };
88718     } catch (Dali::DaliException e) {
88719       {
88720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88721       };
88722     } catch (...) {
88723       {
88724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88725       };
88726     }
88727   }
88728
88729   jresult = (void *)result;
88730   return jresult;
88731 }
88732
88733
88734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
88735   void * jresult ;
88736   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88737   Dali::Toolkit::PageTurnView *arg2 = 0 ;
88738   Dali::Toolkit::PageTurnView *result = 0 ;
88739
88740   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88741   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
88742   if (!arg2) {
88743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88744     return 0;
88745   }
88746   {
88747     try {
88748       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
88749     } catch (std::out_of_range& e) {
88750       {
88751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88752       };
88753     } catch (std::exception& e) {
88754       {
88755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88756       };
88757     } catch (Dali::DaliException e) {
88758       {
88759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88760       };
88761     } catch (...) {
88762       {
88763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88764       };
88765     }
88766   }
88767
88768   jresult = (void *)result;
88769   return jresult;
88770 }
88771
88772
88773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
88774   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88775
88776   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88777   {
88778     try {
88779       delete arg1;
88780     } catch (std::out_of_range& e) {
88781       {
88782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88783       };
88784     } catch (std::exception& e) {
88785       {
88786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88787       };
88788     } catch (Dali::DaliException e) {
88789       {
88790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88791       };
88792     } catch (...) {
88793       {
88794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88795       };
88796     }
88797   }
88798
88799 }
88800
88801
88802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
88803   void * jresult ;
88804   Dali::BaseHandle arg1 ;
88805   Dali::BaseHandle *argp1 ;
88806   Dali::Toolkit::PageTurnView result;
88807
88808   argp1 = (Dali::BaseHandle *)jarg1;
88809   if (!argp1) {
88810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88811     return 0;
88812   }
88813   arg1 = *argp1;
88814   {
88815     try {
88816       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
88817     } catch (std::out_of_range& e) {
88818       {
88819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88820       };
88821     } catch (std::exception& e) {
88822       {
88823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88824       };
88825     } catch (Dali::DaliException e) {
88826       {
88827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88828       };
88829     } catch (...) {
88830       {
88831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88832       };
88833     }
88834   }
88835
88836   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
88837   return jresult;
88838 }
88839
88840
88841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
88842   void * jresult ;
88843   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88844   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
88845
88846   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88847   {
88848     try {
88849       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
88850     } catch (std::out_of_range& e) {
88851       {
88852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88853       };
88854     } catch (std::exception& e) {
88855       {
88856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88857       };
88858     } catch (Dali::DaliException e) {
88859       {
88860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88861       };
88862     } catch (...) {
88863       {
88864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88865       };
88866     }
88867   }
88868
88869   jresult = (void *)result;
88870   return jresult;
88871 }
88872
88873
88874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
88875   void * jresult ;
88876   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88877   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
88878
88879   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88880   {
88881     try {
88882       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
88883     } catch (std::out_of_range& e) {
88884       {
88885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88886       };
88887     } catch (std::exception& e) {
88888       {
88889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88890       };
88891     } catch (Dali::DaliException e) {
88892       {
88893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88894       };
88895     } catch (...) {
88896       {
88897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88898       };
88899     }
88900   }
88901
88902   jresult = (void *)result;
88903   return jresult;
88904 }
88905
88906
88907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
88908   void * jresult ;
88909   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88910   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
88911
88912   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88913   {
88914     try {
88915       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
88916     } catch (std::out_of_range& e) {
88917       {
88918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88919       };
88920     } catch (std::exception& e) {
88921       {
88922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88923       };
88924     } catch (Dali::DaliException e) {
88925       {
88926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88927       };
88928     } catch (...) {
88929       {
88930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88931       };
88932     }
88933   }
88934
88935   jresult = (void *)result;
88936   return jresult;
88937 }
88938
88939
88940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
88941   void * jresult ;
88942   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88943   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
88944
88945   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88946   {
88947     try {
88948       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
88949     } catch (std::out_of_range& e) {
88950       {
88951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88952       };
88953     } catch (std::exception& e) {
88954       {
88955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88956       };
88957     } catch (Dali::DaliException e) {
88958       {
88959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88960       };
88961     } catch (...) {
88962       {
88963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88964       };
88965     }
88966   }
88967
88968   jresult = (void *)result;
88969   return jresult;
88970 }
88971
88972
88973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
88974   void * jresult ;
88975   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
88976
88977   {
88978     try {
88979       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
88980     } catch (std::out_of_range& e) {
88981       {
88982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88983       };
88984     } catch (std::exception& e) {
88985       {
88986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88987       };
88988     } catch (Dali::DaliException e) {
88989       {
88990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88991       };
88992     } catch (...) {
88993       {
88994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88995       };
88996     }
88997   }
88998
88999   jresult = (void *)result;
89000   return jresult;
89001 }
89002
89003
89004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
89005   void * jresult ;
89006   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
89007   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89008
89009   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89010   if (!arg1) {
89011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89012     return 0;
89013   }
89014   {
89015     try {
89016       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
89017     } catch (std::out_of_range& e) {
89018       {
89019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89020       };
89021     } catch (std::exception& e) {
89022       {
89023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89024       };
89025     } catch (Dali::DaliException e) {
89026       {
89027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89028       };
89029     } catch (...) {
89030       {
89031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89032       };
89033     }
89034   }
89035
89036   jresult = (void *)result;
89037   return jresult;
89038 }
89039
89040
89041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
89042   void * jresult ;
89043   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89044   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
89045   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89046
89047   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89048   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
89049   if (!arg2) {
89050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89051     return 0;
89052   }
89053   {
89054     try {
89055       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
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 = (void *)result;
89076   return jresult;
89077 }
89078
89079
89080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
89081   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89082
89083   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89084   {
89085     try {
89086       delete arg1;
89087     } catch (std::out_of_range& e) {
89088       {
89089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89090       };
89091     } catch (std::exception& e) {
89092       {
89093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89094       };
89095     } catch (Dali::DaliException e) {
89096       {
89097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89098       };
89099     } catch (...) {
89100       {
89101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89102       };
89103     }
89104   }
89105
89106 }
89107
89108
89109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
89110   void * jresult ;
89111   Dali::Toolkit::PageFactory *arg1 = 0 ;
89112   Dali::Vector2 *arg2 = 0 ;
89113   Dali::Toolkit::PageTurnLandscapeView result;
89114
89115   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89116   if (!arg1) {
89117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89118     return 0;
89119   }
89120   arg2 = (Dali::Vector2 *)jarg2;
89121   if (!arg2) {
89122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89123     return 0;
89124   }
89125   {
89126     try {
89127       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
89128     } catch (std::out_of_range& e) {
89129       {
89130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89131       };
89132     } catch (std::exception& e) {
89133       {
89134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89135       };
89136     } catch (Dali::DaliException e) {
89137       {
89138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89139       };
89140     } catch (...) {
89141       {
89142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89143       };
89144     }
89145   }
89146
89147   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89148   return jresult;
89149 }
89150
89151
89152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
89153   void * jresult ;
89154   Dali::BaseHandle arg1 ;
89155   Dali::BaseHandle *argp1 ;
89156   Dali::Toolkit::PageTurnLandscapeView result;
89157
89158   argp1 = (Dali::BaseHandle *)jarg1;
89159   if (!argp1) {
89160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89161     return 0;
89162   }
89163   arg1 = *argp1;
89164   {
89165     try {
89166       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
89167     } catch (std::out_of_range& e) {
89168       {
89169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89170       };
89171     } catch (std::exception& e) {
89172       {
89173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89174       };
89175     } catch (Dali::DaliException e) {
89176       {
89177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89178       };
89179     } catch (...) {
89180       {
89181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89182       };
89183     }
89184   }
89185
89186   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89187   return jresult;
89188 }
89189
89190
89191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
89192   void * jresult ;
89193   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89194
89195   {
89196     try {
89197       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
89198     } catch (std::out_of_range& e) {
89199       {
89200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89201       };
89202     } catch (std::exception& e) {
89203       {
89204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89205       };
89206     } catch (Dali::DaliException e) {
89207       {
89208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89209       };
89210     } catch (...) {
89211       {
89212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89213       };
89214     }
89215   }
89216
89217   jresult = (void *)result;
89218   return jresult;
89219 }
89220
89221
89222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
89223   void * jresult ;
89224   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
89225   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89226
89227   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89228   if (!arg1) {
89229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89230     return 0;
89231   }
89232   {
89233     try {
89234       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
89235     } catch (std::out_of_range& e) {
89236       {
89237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89238       };
89239     } catch (std::exception& e) {
89240       {
89241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89242       };
89243     } catch (Dali::DaliException e) {
89244       {
89245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89246       };
89247     } catch (...) {
89248       {
89249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89250       };
89251     }
89252   }
89253
89254   jresult = (void *)result;
89255   return jresult;
89256 }
89257
89258
89259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
89260   void * jresult ;
89261   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89262   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
89263   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89264
89265   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89266   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
89267   if (!arg2) {
89268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89269     return 0;
89270   }
89271   {
89272     try {
89273       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
89274     } catch (std::out_of_range& e) {
89275       {
89276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89277       };
89278     } catch (std::exception& e) {
89279       {
89280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89281       };
89282     } catch (Dali::DaliException e) {
89283       {
89284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89285       };
89286     } catch (...) {
89287       {
89288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89289       };
89290     }
89291   }
89292
89293   jresult = (void *)result;
89294   return jresult;
89295 }
89296
89297
89298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
89299   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89300
89301   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89302   {
89303     try {
89304       delete arg1;
89305     } catch (std::out_of_range& e) {
89306       {
89307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89308       };
89309     } catch (std::exception& e) {
89310       {
89311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89312       };
89313     } catch (Dali::DaliException e) {
89314       {
89315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89316       };
89317     } catch (...) {
89318       {
89319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89320       };
89321     }
89322   }
89323
89324 }
89325
89326
89327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
89328   void * jresult ;
89329   Dali::Toolkit::PageFactory *arg1 = 0 ;
89330   Dali::Vector2 *arg2 = 0 ;
89331   Dali::Toolkit::PageTurnPortraitView result;
89332
89333   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89334   if (!arg1) {
89335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89336     return 0;
89337   }
89338   arg2 = (Dali::Vector2 *)jarg2;
89339   if (!arg2) {
89340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89341     return 0;
89342   }
89343   {
89344     try {
89345       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
89346     } catch (std::out_of_range& e) {
89347       {
89348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89349       };
89350     } catch (std::exception& e) {
89351       {
89352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89353       };
89354     } catch (Dali::DaliException e) {
89355       {
89356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89357       };
89358     } catch (...) {
89359       {
89360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89361       };
89362     }
89363   }
89364
89365   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89366   return jresult;
89367 }
89368
89369
89370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
89371   void * jresult ;
89372   Dali::BaseHandle arg1 ;
89373   Dali::BaseHandle *argp1 ;
89374   Dali::Toolkit::PageTurnPortraitView result;
89375
89376   argp1 = (Dali::BaseHandle *)jarg1;
89377   if (!argp1) {
89378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89379     return 0;
89380   }
89381   arg1 = *argp1;
89382   {
89383     try {
89384       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
89385     } catch (std::out_of_range& e) {
89386       {
89387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89388       };
89389     } catch (std::exception& e) {
89390       {
89391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89392       };
89393     } catch (Dali::DaliException e) {
89394       {
89395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89396       };
89397     } catch (...) {
89398       {
89399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89400       };
89401     }
89402   }
89403
89404   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89405   return jresult;
89406 }
89407
89408
89409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
89410   int jresult ;
89411   int result;
89412
89413   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
89414   jresult = (int)result;
89415   return jresult;
89416 }
89417
89418
89419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
89420   int jresult ;
89421   int result;
89422
89423   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
89424   jresult = (int)result;
89425   return jresult;
89426 }
89427
89428
89429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
89430   int jresult ;
89431   int result;
89432
89433   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
89434   jresult = (int)result;
89435   return jresult;
89436 }
89437
89438
89439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
89440   void * jresult ;
89441   Dali::Toolkit::ToggleButton::Property *result = 0 ;
89442
89443   {
89444     try {
89445       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
89446     } catch (std::out_of_range& e) {
89447       {
89448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89449       };
89450     } catch (std::exception& e) {
89451       {
89452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89453       };
89454     } catch (Dali::DaliException e) {
89455       {
89456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89457       };
89458     } catch (...) {
89459       {
89460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89461       };
89462     }
89463   }
89464
89465   jresult = (void *)result;
89466   return jresult;
89467 }
89468
89469
89470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
89471   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
89472
89473   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
89474   {
89475     try {
89476       delete arg1;
89477     } catch (std::out_of_range& e) {
89478       {
89479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89480       };
89481     } catch (std::exception& e) {
89482       {
89483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89484       };
89485     } catch (Dali::DaliException e) {
89486       {
89487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89488       };
89489     } catch (...) {
89490       {
89491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89492       };
89493     }
89494   }
89495
89496 }
89497
89498
89499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
89500   void * jresult ;
89501   Dali::Toolkit::ToggleButton *result = 0 ;
89502
89503   {
89504     try {
89505       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
89506     } catch (std::out_of_range& e) {
89507       {
89508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89509       };
89510     } catch (std::exception& e) {
89511       {
89512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89513       };
89514     } catch (Dali::DaliException e) {
89515       {
89516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89517       };
89518     } catch (...) {
89519       {
89520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89521       };
89522     }
89523   }
89524
89525   jresult = (void *)result;
89526   return jresult;
89527 }
89528
89529
89530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
89531   void * jresult ;
89532   Dali::Toolkit::ToggleButton *arg1 = 0 ;
89533   Dali::Toolkit::ToggleButton *result = 0 ;
89534
89535   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89536   if (!arg1) {
89537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89538     return 0;
89539   }
89540   {
89541     try {
89542       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
89543     } catch (std::out_of_range& e) {
89544       {
89545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89546       };
89547     } catch (std::exception& e) {
89548       {
89549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89550       };
89551     } catch (Dali::DaliException e) {
89552       {
89553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89554       };
89555     } catch (...) {
89556       {
89557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89558       };
89559     }
89560   }
89561
89562   jresult = (void *)result;
89563   return jresult;
89564 }
89565
89566
89567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
89568   void * jresult ;
89569   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89570   Dali::Toolkit::ToggleButton *arg2 = 0 ;
89571   Dali::Toolkit::ToggleButton *result = 0 ;
89572
89573   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89574   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
89575   if (!arg2) {
89576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89577     return 0;
89578   }
89579   {
89580     try {
89581       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
89582     } catch (std::out_of_range& e) {
89583       {
89584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89585       };
89586     } catch (std::exception& e) {
89587       {
89588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89589       };
89590     } catch (Dali::DaliException e) {
89591       {
89592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89593       };
89594     } catch (...) {
89595       {
89596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89597       };
89598     }
89599   }
89600
89601   jresult = (void *)result;
89602   return jresult;
89603 }
89604
89605
89606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
89607   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89608
89609   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89610   {
89611     try {
89612       delete arg1;
89613     } catch (std::out_of_range& e) {
89614       {
89615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89616       };
89617     } catch (std::exception& e) {
89618       {
89619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89620       };
89621     } catch (Dali::DaliException e) {
89622       {
89623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89624       };
89625     } catch (...) {
89626       {
89627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89628       };
89629     }
89630   }
89631
89632 }
89633
89634
89635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
89636   void * jresult ;
89637   Dali::Toolkit::ToggleButton result;
89638
89639   {
89640     try {
89641       result = Dali::Toolkit::ToggleButton::New();
89642     } catch (std::out_of_range& e) {
89643       {
89644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89645       };
89646     } catch (std::exception& e) {
89647       {
89648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89649       };
89650     } catch (Dali::DaliException e) {
89651       {
89652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89653       };
89654     } catch (...) {
89655       {
89656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89657       };
89658     }
89659   }
89660
89661   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89662   return jresult;
89663 }
89664
89665
89666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
89667   void * jresult ;
89668   Dali::BaseHandle arg1 ;
89669   Dali::BaseHandle *argp1 ;
89670   Dali::Toolkit::ToggleButton result;
89671
89672   argp1 = (Dali::BaseHandle *)jarg1;
89673   if (!argp1) {
89674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89675     return 0;
89676   }
89677   arg1 = *argp1;
89678   {
89679     try {
89680       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
89681     } catch (std::out_of_range& e) {
89682       {
89683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89684       };
89685     } catch (std::exception& e) {
89686       {
89687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89688       };
89689     } catch (Dali::DaliException e) {
89690       {
89691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89692       };
89693     } catch (...) {
89694       {
89695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89696       };
89697     }
89698   }
89699
89700   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89701   return jresult;
89702 }
89703
89704
89705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
89706   void * jresult ;
89707   Dali::Toolkit::Visual::Base *result = 0 ;
89708
89709   {
89710     try {
89711       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
89712     } catch (std::out_of_range& e) {
89713       {
89714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89715       };
89716     } catch (std::exception& e) {
89717       {
89718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89719       };
89720     } catch (Dali::DaliException e) {
89721       {
89722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89723       };
89724     } catch (...) {
89725       {
89726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89727       };
89728     }
89729   }
89730
89731   jresult = (void *)result;
89732   return jresult;
89733 }
89734
89735
89736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
89737   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89738
89739   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89740   {
89741     try {
89742       delete arg1;
89743     } catch (std::out_of_range& e) {
89744       {
89745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89746       };
89747     } catch (std::exception& e) {
89748       {
89749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89750       };
89751     } catch (Dali::DaliException e) {
89752       {
89753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89754       };
89755     } catch (...) {
89756       {
89757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89758       };
89759     }
89760   }
89761
89762 }
89763
89764
89765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
89766   void * jresult ;
89767   Dali::Toolkit::Visual::Base *arg1 = 0 ;
89768   Dali::Toolkit::Visual::Base *result = 0 ;
89769
89770   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89771   if (!arg1) {
89772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
89773     return 0;
89774   }
89775   {
89776     try {
89777       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
89778     } catch (std::out_of_range& e) {
89779       {
89780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89781       };
89782     } catch (std::exception& e) {
89783       {
89784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89785       };
89786     } catch (Dali::DaliException e) {
89787       {
89788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89789       };
89790     } catch (...) {
89791       {
89792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89793       };
89794     }
89795   }
89796
89797   jresult = (void *)result;
89798   return jresult;
89799 }
89800
89801
89802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
89803   void * jresult ;
89804   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89805   Dali::Toolkit::Visual::Base *arg2 = 0 ;
89806   Dali::Toolkit::Visual::Base *result = 0 ;
89807
89808   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89809   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
89810   if (!arg2) {
89811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
89812     return 0;
89813   }
89814   {
89815     try {
89816       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
89817     } catch (std::out_of_range& e) {
89818       {
89819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89820       };
89821     } catch (std::exception& e) {
89822       {
89823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89824       };
89825     } catch (Dali::DaliException e) {
89826       {
89827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89828       };
89829     } catch (...) {
89830       {
89831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89832       };
89833     }
89834   }
89835
89836   jresult = (void *)result;
89837   return jresult;
89838 }
89839
89840
89841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
89842   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89843   std::string *arg2 = 0 ;
89844
89845   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89846   if (!jarg2) {
89847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89848     return ;
89849   }
89850   std::string arg2_str(jarg2);
89851   arg2 = &arg2_str;
89852   {
89853     try {
89854       (arg1)->SetName((std::string const &)*arg2);
89855     } catch (std::out_of_range& e) {
89856       {
89857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89858       };
89859     } catch (std::exception& e) {
89860       {
89861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89862       };
89863     } catch (Dali::DaliException e) {
89864       {
89865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89866       };
89867     } catch (...) {
89868       {
89869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89870       };
89871     }
89872   }
89873
89874
89875   //argout typemap for const std::string&
89876
89877 }
89878
89879
89880 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
89881   char * jresult ;
89882   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89883   std::string *result = 0 ;
89884
89885   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89886   {
89887     try {
89888       result = (std::string *) &(arg1)->GetName();
89889     } catch (std::out_of_range& e) {
89890       {
89891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89892       };
89893     } catch (std::exception& e) {
89894       {
89895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89896       };
89897     } catch (Dali::DaliException e) {
89898       {
89899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89900       };
89901     } catch (...) {
89902       {
89903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89904       };
89905     }
89906   }
89907
89908   jresult = SWIG_csharp_string_callback(result->c_str());
89909   return jresult;
89910 }
89911
89912
89913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
89914   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89915   Dali::Property::Map *arg2 = 0 ;
89916   Dali::Size arg3 ;
89917   Dali::Size *argp3 ;
89918
89919   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89920   arg2 = (Dali::Property::Map *)jarg2;
89921   if (!arg2) {
89922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
89923     return ;
89924   }
89925   argp3 = (Dali::Size *)jarg3;
89926   if (!argp3) {
89927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
89928     return ;
89929   }
89930   arg3 = *argp3;
89931   {
89932     try {
89933       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
89934     } catch (std::out_of_range& e) {
89935       {
89936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89937       };
89938     } catch (std::exception& e) {
89939       {
89940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89941       };
89942     } catch (Dali::DaliException e) {
89943       {
89944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89945       };
89946     } catch (...) {
89947       {
89948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89949       };
89950     }
89951   }
89952
89953 }
89954
89955
89956 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
89957   float jresult ;
89958   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89959   float arg2 ;
89960   float result;
89961
89962   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89963   arg2 = (float)jarg2;
89964   {
89965     try {
89966       result = (float)(arg1)->GetHeightForWidth(arg2);
89967     } catch (std::out_of_range& e) {
89968       {
89969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89970       };
89971     } catch (std::exception& e) {
89972       {
89973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89974       };
89975     } catch (Dali::DaliException e) {
89976       {
89977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89978       };
89979     } catch (...) {
89980       {
89981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89982       };
89983     }
89984   }
89985
89986   jresult = result;
89987   return jresult;
89988 }
89989
89990
89991 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
89992   float jresult ;
89993   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89994   float arg2 ;
89995   float result;
89996
89997   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89998   arg2 = (float)jarg2;
89999   {
90000     try {
90001       result = (float)(arg1)->GetWidthForHeight(arg2);
90002     } catch (std::out_of_range& e) {
90003       {
90004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90005       };
90006     } catch (std::exception& e) {
90007       {
90008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90009       };
90010     } catch (Dali::DaliException e) {
90011       {
90012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90013       };
90014     } catch (...) {
90015       {
90016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90017       };
90018     }
90019   }
90020
90021   jresult = result;
90022   return jresult;
90023 }
90024
90025
90026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
90027   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90028   Dali::Vector2 *arg2 = 0 ;
90029
90030   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90031   arg2 = (Dali::Vector2 *)jarg2;
90032   if (!arg2) {
90033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
90034     return ;
90035   }
90036   {
90037     try {
90038       (arg1)->GetNaturalSize(*arg2);
90039     } catch (std::out_of_range& e) {
90040       {
90041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90042       };
90043     } catch (std::exception& e) {
90044       {
90045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90046       };
90047     } catch (Dali::DaliException e) {
90048       {
90049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90050       };
90051     } catch (...) {
90052       {
90053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90054       };
90055     }
90056   }
90057
90058 }
90059
90060
90061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
90062   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90063   float arg2 ;
90064
90065   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90066   arg2 = (int)jarg2;
90067   {
90068     try {
90069       (arg1)->SetDepthIndex(arg2);
90070     } catch (std::out_of_range& e) {
90071       {
90072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90073       };
90074     } catch (std::exception& e) {
90075       {
90076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90077       };
90078     } catch (Dali::DaliException e) {
90079       {
90080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90081       };
90082     } catch (...) {
90083       {
90084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90085       };
90086     }
90087   }
90088
90089 }
90090
90091
90092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
90093   int jresult ;
90094   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90095   int result;
90096
90097   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90098   {
90099     try {
90100       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
90101     } catch (std::out_of_range& e) {
90102       {
90103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90104       };
90105     } catch (std::exception& e) {
90106       {
90107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90108       };
90109     } catch (Dali::DaliException e) {
90110       {
90111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90112       };
90113     } catch (...) {
90114       {
90115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90116       };
90117     }
90118   }
90119
90120   jresult = result;
90121   return jresult;
90122 }
90123
90124
90125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
90126   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90127   Dali::Property::Map *arg2 = 0 ;
90128
90129   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90130   arg2 = (Dali::Property::Map *)jarg2;
90131   if (!arg2) {
90132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
90133     return ;
90134   }
90135   {
90136     try {
90137       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
90138     } catch (std::out_of_range& e) {
90139       {
90140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90141       };
90142     } catch (std::exception& e) {
90143       {
90144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90145       };
90146     } catch (Dali::DaliException e) {
90147       {
90148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90149       };
90150     } catch (...) {
90151       {
90152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90153       };
90154     }
90155   }
90156
90157 }
90158
90159
90160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
90161   void * jresult ;
90162   Dali::Toolkit::VisualFactory result;
90163
90164   {
90165     try {
90166       result = Dali::Toolkit::VisualFactory::Get();
90167     } catch (std::out_of_range& e) {
90168       {
90169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90170       };
90171     } catch (std::exception& e) {
90172       {
90173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90174       };
90175     } catch (Dali::DaliException e) {
90176       {
90177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90178       };
90179     } catch (...) {
90180       {
90181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90182       };
90183     }
90184   }
90185
90186   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
90187   return jresult;
90188 }
90189
90190
90191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
90192   void * jresult ;
90193   Dali::Toolkit::VisualFactory *result = 0 ;
90194
90195   {
90196     try {
90197       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
90198     } catch (std::out_of_range& e) {
90199       {
90200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90201       };
90202     } catch (std::exception& e) {
90203       {
90204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90205       };
90206     } catch (Dali::DaliException e) {
90207       {
90208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90209       };
90210     } catch (...) {
90211       {
90212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90213       };
90214     }
90215   }
90216
90217   jresult = (void *)result;
90218   return jresult;
90219 }
90220
90221
90222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
90223   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90224
90225   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90226   {
90227     try {
90228       delete arg1;
90229     } catch (std::out_of_range& e) {
90230       {
90231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90232       };
90233     } catch (std::exception& e) {
90234       {
90235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90236       };
90237     } catch (Dali::DaliException e) {
90238       {
90239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90240       };
90241     } catch (...) {
90242       {
90243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90244       };
90245     }
90246   }
90247
90248 }
90249
90250
90251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
90252   void * jresult ;
90253   Dali::Toolkit::VisualFactory *arg1 = 0 ;
90254   Dali::Toolkit::VisualFactory *result = 0 ;
90255
90256   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90257   if (!arg1) {
90258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90259     return 0;
90260   }
90261   {
90262     try {
90263       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
90264     } catch (std::out_of_range& e) {
90265       {
90266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90267       };
90268     } catch (std::exception& e) {
90269       {
90270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90271       };
90272     } catch (Dali::DaliException e) {
90273       {
90274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90275       };
90276     } catch (...) {
90277       {
90278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90279       };
90280     }
90281   }
90282
90283   jresult = (void *)result;
90284   return jresult;
90285 }
90286
90287
90288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
90289   void * jresult ;
90290   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90291   Dali::Toolkit::VisualFactory *arg2 = 0 ;
90292   Dali::Toolkit::VisualFactory *result = 0 ;
90293
90294   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90295   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
90296   if (!arg2) {
90297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90298     return 0;
90299   }
90300   {
90301     try {
90302       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
90303     } catch (std::out_of_range& e) {
90304       {
90305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90306       };
90307     } catch (std::exception& e) {
90308       {
90309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90310       };
90311     } catch (Dali::DaliException e) {
90312       {
90313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90314       };
90315     } catch (...) {
90316       {
90317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90318       };
90319     }
90320   }
90321
90322   jresult = (void *)result;
90323   return jresult;
90324 }
90325
90326
90327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
90328   void * jresult ;
90329   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90330   Dali::Property::Map *arg2 = 0 ;
90331   Dali::Toolkit::Visual::Base result;
90332
90333   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90334   arg2 = (Dali::Property::Map *)jarg2;
90335   if (!arg2) {
90336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90337     return 0;
90338   }
90339   {
90340     try {
90341       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
90342     } catch (std::out_of_range& e) {
90343       {
90344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90345       };
90346     } catch (std::exception& e) {
90347       {
90348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90349       };
90350     } catch (Dali::DaliException e) {
90351       {
90352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90353       };
90354     } catch (...) {
90355       {
90356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90357       };
90358     }
90359   }
90360
90361   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90362   return jresult;
90363 }
90364
90365
90366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
90367   void * jresult ;
90368   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90369   Dali::Image *arg2 = 0 ;
90370   Dali::Toolkit::Visual::Base result;
90371
90372   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90373   arg2 = (Dali::Image *)jarg2;
90374   if (!arg2) {
90375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
90376     return 0;
90377   }
90378   {
90379     try {
90380       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
90381     } catch (std::out_of_range& e) {
90382       {
90383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90384       };
90385     } catch (std::exception& e) {
90386       {
90387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90388       };
90389     } catch (Dali::DaliException e) {
90390       {
90391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90392       };
90393     } catch (...) {
90394       {
90395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90396       };
90397     }
90398   }
90399
90400   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90401   return jresult;
90402 }
90403
90404
90405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
90406   void * jresult ;
90407   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90408   std::string *arg2 = 0 ;
90409   Dali::ImageDimensions arg3 ;
90410   Dali::ImageDimensions *argp3 ;
90411   Dali::Toolkit::Visual::Base result;
90412
90413   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90414   if (!jarg2) {
90415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90416     return 0;
90417   }
90418   std::string arg2_str(jarg2);
90419   arg2 = &arg2_str;
90420   argp3 = (Dali::ImageDimensions *)jarg3;
90421   if (!argp3) {
90422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90423     return 0;
90424   }
90425   arg3 = *argp3;
90426   {
90427     try {
90428       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
90429     } catch (std::out_of_range& e) {
90430       {
90431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90432       };
90433     } catch (std::exception& e) {
90434       {
90435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90436       };
90437     } catch (Dali::DaliException e) {
90438       {
90439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90440       };
90441     } catch (...) {
90442       {
90443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90444       };
90445     }
90446   }
90447
90448   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90449
90450   //argout typemap for const std::string&
90451
90452   return jresult;
90453 }
90454
90455
90456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
90457   void * jresult ;
90458   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90459
90460   {
90461     try {
90462       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
90463     } catch (std::out_of_range& e) {
90464       {
90465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90466       };
90467     } catch (std::exception& e) {
90468       {
90469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90470       };
90471     } catch (Dali::DaliException e) {
90472       {
90473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90474       };
90475     } catch (...) {
90476       {
90477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90478       };
90479     }
90480   }
90481
90482   jresult = (void *)result;
90483   return jresult;
90484 }
90485
90486
90487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
90488   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90489
90490   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90491   {
90492     try {
90493       delete arg1;
90494     } catch (std::out_of_range& e) {
90495       {
90496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90497       };
90498     } catch (std::exception& e) {
90499       {
90500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90501       };
90502     } catch (Dali::DaliException e) {
90503       {
90504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90505       };
90506     } catch (...) {
90507       {
90508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90509       };
90510     }
90511   }
90512
90513 }
90514
90515
90516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
90517   void * jresult ;
90518   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
90519   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90520
90521   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90522   if (!arg1) {
90523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90524     return 0;
90525   }
90526   {
90527     try {
90528       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
90529     } catch (std::out_of_range& e) {
90530       {
90531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90532       };
90533     } catch (std::exception& e) {
90534       {
90535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90536       };
90537     } catch (Dali::DaliException e) {
90538       {
90539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90540       };
90541     } catch (...) {
90542       {
90543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90544       };
90545     }
90546   }
90547
90548   jresult = (void *)result;
90549   return jresult;
90550 }
90551
90552
90553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
90554   void * jresult ;
90555   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90556   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
90557   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90558
90559   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90560   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
90561   if (!arg2) {
90562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90563     return 0;
90564   }
90565   {
90566     try {
90567       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
90568     } catch (std::out_of_range& e) {
90569       {
90570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90571       };
90572     } catch (std::exception& e) {
90573       {
90574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90575       };
90576     } catch (Dali::DaliException e) {
90577       {
90578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90579       };
90580     } catch (...) {
90581       {
90582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90583       };
90584     }
90585   }
90586
90587   jresult = (void *)result;
90588   return jresult;
90589 }
90590
90591
90592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
90593   void * jresult ;
90594   Dali::Toolkit::AsyncImageLoader result;
90595
90596   {
90597     try {
90598       result = Dali::Toolkit::AsyncImageLoader::New();
90599     } catch (std::out_of_range& e) {
90600       {
90601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90602       };
90603     } catch (std::exception& e) {
90604       {
90605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90606       };
90607     } catch (Dali::DaliException e) {
90608       {
90609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90610       };
90611     } catch (...) {
90612       {
90613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90614       };
90615     }
90616   }
90617
90618   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90619   return jresult;
90620 }
90621
90622
90623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
90624   void * jresult ;
90625   Dali::BaseHandle arg1 ;
90626   Dali::BaseHandle *argp1 ;
90627   Dali::Toolkit::AsyncImageLoader result;
90628
90629   argp1 = (Dali::BaseHandle *)jarg1;
90630   if (!argp1) {
90631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90632     return 0;
90633   }
90634   arg1 = *argp1;
90635   {
90636     try {
90637       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
90638     } catch (std::out_of_range& e) {
90639       {
90640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90641       };
90642     } catch (std::exception& e) {
90643       {
90644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90645       };
90646     } catch (Dali::DaliException e) {
90647       {
90648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90649       };
90650     } catch (...) {
90651       {
90652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90653       };
90654     }
90655   }
90656
90657   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90658   return jresult;
90659 }
90660
90661
90662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
90663   unsigned int jresult ;
90664   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90665   std::string *arg2 = 0 ;
90666   uint32_t result;
90667
90668   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90669   if (!jarg2) {
90670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90671     return 0;
90672   }
90673   std::string arg2_str(jarg2);
90674   arg2 = &arg2_str;
90675   {
90676     try {
90677       result = (arg1)->Load((std::string const &)*arg2);
90678     } catch (std::out_of_range& e) {
90679       {
90680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90681       };
90682     } catch (std::exception& e) {
90683       {
90684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90685       };
90686     } catch (Dali::DaliException e) {
90687       {
90688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90689       };
90690     } catch (...) {
90691       {
90692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90693       };
90694     }
90695   }
90696
90697   jresult = result;
90698
90699   //argout typemap for const std::string&
90700
90701   return jresult;
90702 }
90703
90704
90705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
90706   unsigned int jresult ;
90707   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90708   std::string *arg2 = 0 ;
90709   Dali::ImageDimensions arg3 ;
90710   Dali::ImageDimensions *argp3 ;
90711   uint32_t result;
90712
90713   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90714   if (!jarg2) {
90715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90716     return 0;
90717   }
90718   std::string arg2_str(jarg2);
90719   arg2 = &arg2_str;
90720   argp3 = (Dali::ImageDimensions *)jarg3;
90721   if (!argp3) {
90722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90723     return 0;
90724   }
90725   arg3 = *argp3;
90726   {
90727     try {
90728       result = (arg1)->Load((std::string const &)*arg2,arg3);
90729     } catch (std::out_of_range& e) {
90730       {
90731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90732       };
90733     } catch (std::exception& e) {
90734       {
90735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90736       };
90737     } catch (Dali::DaliException e) {
90738       {
90739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90740       };
90741     } catch (...) {
90742       {
90743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90744       };
90745     }
90746   }
90747
90748   jresult = result;
90749
90750   //argout typemap for const std::string&
90751
90752   return jresult;
90753 }
90754
90755
90756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
90757   unsigned int jresult ;
90758   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90759   std::string *arg2 = 0 ;
90760   Dali::ImageDimensions arg3 ;
90761   Dali::FittingMode::Type arg4 ;
90762   Dali::SamplingMode::Type arg5 ;
90763   bool arg6 ;
90764   Dali::ImageDimensions *argp3 ;
90765   uint32_t result;
90766
90767   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90768   if (!jarg2) {
90769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90770     return 0;
90771   }
90772   std::string arg2_str(jarg2);
90773   arg2 = &arg2_str;
90774   argp3 = (Dali::ImageDimensions *)jarg3;
90775   if (!argp3) {
90776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90777     return 0;
90778   }
90779   arg3 = *argp3;
90780   arg4 = (Dali::FittingMode::Type)jarg4;
90781   arg5 = (Dali::SamplingMode::Type)jarg5;
90782   arg6 = jarg6 ? true : false;
90783   {
90784     try {
90785       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
90786     } catch (std::out_of_range& e) {
90787       {
90788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90789       };
90790     } catch (std::exception& e) {
90791       {
90792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90793       };
90794     } catch (Dali::DaliException e) {
90795       {
90796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90797       };
90798     } catch (...) {
90799       {
90800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90801       };
90802     }
90803   }
90804
90805   jresult = result;
90806
90807   //argout typemap for const std::string&
90808
90809   return jresult;
90810 }
90811
90812
90813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
90814   unsigned int jresult ;
90815   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90816   uint32_t arg2 ;
90817   bool result;
90818
90819   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90820   arg2 = (uint32_t)jarg2;
90821   {
90822     try {
90823       result = (bool)(arg1)->Cancel(arg2);
90824     } catch (std::out_of_range& e) {
90825       {
90826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90827       };
90828     } catch (std::exception& e) {
90829       {
90830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90831       };
90832     } catch (Dali::DaliException e) {
90833       {
90834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90835       };
90836     } catch (...) {
90837       {
90838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90839       };
90840     }
90841   }
90842
90843   jresult = result;
90844   return jresult;
90845 }
90846
90847
90848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
90849   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90850
90851   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90852   {
90853     try {
90854       (arg1)->CancelAll();
90855     } catch (std::out_of_range& e) {
90856       {
90857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90858       };
90859     } catch (std::exception& e) {
90860       {
90861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90862       };
90863     } catch (Dali::DaliException e) {
90864       {
90865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90866       };
90867     } catch (...) {
90868       {
90869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90870       };
90871     }
90872   }
90873
90874 }
90875
90876
90877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
90878   void * jresult ;
90879   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90880   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
90881
90882   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90883   {
90884     try {
90885       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
90886     } catch (std::out_of_range& e) {
90887       {
90888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90889       };
90890     } catch (std::exception& e) {
90891       {
90892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90893       };
90894     } catch (Dali::DaliException e) {
90895       {
90896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90897       };
90898     } catch (...) {
90899       {
90900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90901       };
90902     }
90903   }
90904
90905   jresult = (void *)result;
90906   return jresult;
90907 }
90908
90909
90910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
90911   void * jresult ;
90912   std::string *arg1 = 0 ;
90913   Dali::PixelData result;
90914
90915   if (!jarg1) {
90916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90917     return 0;
90918   }
90919   std::string arg1_str(jarg1);
90920   arg1 = &arg1_str;
90921   {
90922     try {
90923       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
90924     } catch (std::out_of_range& e) {
90925       {
90926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90927       };
90928     } catch (std::exception& e) {
90929       {
90930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90931       };
90932     } catch (Dali::DaliException e) {
90933       {
90934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90935       };
90936     } catch (...) {
90937       {
90938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90939       };
90940     }
90941   }
90942
90943   jresult = new Dali::PixelData((const Dali::PixelData &)result);
90944
90945   //argout typemap for const std::string&
90946
90947   return jresult;
90948 }
90949
90950
90951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
90952   void * jresult ;
90953   std::string *arg1 = 0 ;
90954   Dali::ImageDimensions arg2 ;
90955   Dali::ImageDimensions *argp2 ;
90956   Dali::PixelData result;
90957
90958   if (!jarg1) {
90959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90960     return 0;
90961   }
90962   std::string arg1_str(jarg1);
90963   arg1 = &arg1_str;
90964   argp2 = (Dali::ImageDimensions *)jarg2;
90965   if (!argp2) {
90966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90967     return 0;
90968   }
90969   arg2 = *argp2;
90970   {
90971     try {
90972       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
90973     } catch (std::out_of_range& e) {
90974       {
90975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90976       };
90977     } catch (std::exception& e) {
90978       {
90979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90980       };
90981     } catch (Dali::DaliException e) {
90982       {
90983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90984       };
90985     } catch (...) {
90986       {
90987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90988       };
90989     }
90990   }
90991
90992   jresult = new Dali::PixelData((const Dali::PixelData &)result);
90993
90994   //argout typemap for const std::string&
90995
90996   return jresult;
90997 }
90998
90999
91000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
91001   void * jresult ;
91002   std::string *arg1 = 0 ;
91003   Dali::ImageDimensions arg2 ;
91004   Dali::FittingMode::Type arg3 ;
91005   Dali::SamplingMode::Type arg4 ;
91006   bool arg5 ;
91007   Dali::ImageDimensions *argp2 ;
91008   Dali::PixelData result;
91009
91010   if (!jarg1) {
91011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91012     return 0;
91013   }
91014   std::string arg1_str(jarg1);
91015   arg1 = &arg1_str;
91016   argp2 = (Dali::ImageDimensions *)jarg2;
91017   if (!argp2) {
91018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91019     return 0;
91020   }
91021   arg2 = *argp2;
91022   arg3 = (Dali::FittingMode::Type)jarg3;
91023   arg4 = (Dali::SamplingMode::Type)jarg4;
91024   arg5 = jarg5 ? true : false;
91025   {
91026     try {
91027       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
91028     } catch (std::out_of_range& e) {
91029       {
91030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91031       };
91032     } catch (std::exception& e) {
91033       {
91034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91035       };
91036     } catch (Dali::DaliException e) {
91037       {
91038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91039       };
91040     } catch (...) {
91041       {
91042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91043       };
91044     }
91045   }
91046
91047   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91048
91049   //argout typemap for const std::string&
91050
91051   return jresult;
91052 }
91053
91054
91055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
91056   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91057
91058   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91059   {
91060     try {
91061       delete arg1;
91062     } catch (std::out_of_range& e) {
91063       {
91064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91065       };
91066     } catch (std::exception& e) {
91067       {
91068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91069       };
91070     } catch (Dali::DaliException e) {
91071       {
91072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91073       };
91074     } catch (...) {
91075       {
91076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91077       };
91078     }
91079   }
91080
91081 }
91082
91083
91084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
91085   void * jresult ;
91086   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91087   Dali::Actor arg2 ;
91088   Dali::Actor arg3 ;
91089   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
91090   Dali::Actor *argp2 ;
91091   Dali::Actor *argp3 ;
91092   Dali::Actor result;
91093
91094   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91095   argp2 = (Dali::Actor *)jarg2;
91096   if (!argp2) {
91097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91098     return 0;
91099   }
91100   arg2 = *argp2;
91101   argp3 = (Dali::Actor *)jarg3;
91102   if (!argp3) {
91103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91104     return 0;
91105   }
91106   arg3 = *argp3;
91107   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
91108   {
91109     try {
91110       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
91111     } catch (std::out_of_range& e) {
91112       {
91113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91114       };
91115     } catch (std::exception& e) {
91116       {
91117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91118       };
91119     } catch (Dali::DaliException e) {
91120       {
91121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91122       };
91123     } catch (...) {
91124       {
91125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91126       };
91127     }
91128   }
91129
91130   jresult = new Dali::Actor((const Dali::Actor &)result);
91131   return jresult;
91132 }
91133
91134
91135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
91136   void * jresult ;
91137   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
91138
91139   {
91140     try {
91141       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
91142     } catch (std::out_of_range& e) {
91143       {
91144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91145       };
91146     } catch (std::exception& e) {
91147       {
91148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91149       };
91150     } catch (Dali::DaliException e) {
91151       {
91152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91153       };
91154     } catch (...) {
91155       {
91156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91157       };
91158     }
91159   }
91160
91161   jresult = (void *)result;
91162   return jresult;
91163 }
91164
91165
91166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
91167   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
91168   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
91169   if (director) {
91170     director->swig_connect_director(callback0);
91171   }
91172 }
91173
91174
91175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
91176   KeyboardFocusManager arg1 ;
91177   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
91178   KeyboardFocusManager *argp1 ;
91179
91180   argp1 = (KeyboardFocusManager *)jarg1;
91181   if (!argp1) {
91182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
91183     return ;
91184   }
91185   arg1 = *argp1;
91186   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
91187   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
91188   {
91189     try {
91190       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
91191     } catch (std::out_of_range& e) {
91192       {
91193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91194       };
91195     } catch (std::exception& e) {
91196       {
91197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91198       };
91199     } catch (Dali::DaliException e) {
91200       {
91201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91202       };
91203     } catch (...) {
91204       {
91205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91206       };
91207     }
91208   }
91209
91210 }
91211
91212
91213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
91214   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91215
91216   arg1 = (std::vector< unsigned int > *)jarg1;
91217   {
91218     try {
91219       (arg1)->clear();
91220     } catch (std::out_of_range& e) {
91221       {
91222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91223       };
91224     } catch (std::exception& e) {
91225       {
91226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91227       };
91228     } catch (Dali::DaliException e) {
91229       {
91230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91231       };
91232     } catch (...) {
91233       {
91234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91235       };
91236     }
91237   }
91238
91239 }
91240
91241
91242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
91243   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91244   unsigned int *arg2 = 0 ;
91245   unsigned int temp2 ;
91246
91247   arg1 = (std::vector< unsigned int > *)jarg1;
91248   temp2 = (unsigned int)jarg2;
91249   arg2 = &temp2;
91250   {
91251     try {
91252       (arg1)->push_back((unsigned int const &)*arg2);
91253     } catch (std::out_of_range& e) {
91254       {
91255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91256       };
91257     } catch (std::exception& e) {
91258       {
91259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91260       };
91261     } catch (Dali::DaliException e) {
91262       {
91263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91264       };
91265     } catch (...) {
91266       {
91267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91268       };
91269     }
91270   }
91271
91272 }
91273
91274
91275 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
91276   unsigned long jresult ;
91277   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91278   std::vector< unsigned int >::size_type result;
91279
91280   arg1 = (std::vector< unsigned int > *)jarg1;
91281   {
91282     try {
91283       result = ((std::vector< unsigned int > const *)arg1)->size();
91284     } catch (std::out_of_range& e) {
91285       {
91286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91287       };
91288     } catch (std::exception& e) {
91289       {
91290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91291       };
91292     } catch (Dali::DaliException e) {
91293       {
91294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91295       };
91296     } catch (...) {
91297       {
91298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91299       };
91300     }
91301   }
91302
91303   jresult = (unsigned long)result;
91304   return jresult;
91305 }
91306
91307
91308 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
91309   unsigned long jresult ;
91310   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91311   std::vector< unsigned int >::size_type result;
91312
91313   arg1 = (std::vector< unsigned int > *)jarg1;
91314   {
91315     try {
91316       result = ((std::vector< unsigned int > const *)arg1)->capacity();
91317     } catch (std::out_of_range& e) {
91318       {
91319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91320       };
91321     } catch (std::exception& e) {
91322       {
91323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91324       };
91325     } catch (Dali::DaliException e) {
91326       {
91327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91328       };
91329     } catch (...) {
91330       {
91331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91332       };
91333     }
91334   }
91335
91336   jresult = (unsigned long)result;
91337   return jresult;
91338 }
91339
91340
91341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
91342   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91343   std::vector< unsigned int >::size_type arg2 ;
91344
91345   arg1 = (std::vector< unsigned int > *)jarg1;
91346   arg2 = (std::vector< unsigned int >::size_type)jarg2;
91347   {
91348     try {
91349       (arg1)->reserve(arg2);
91350     } catch (std::out_of_range& e) {
91351       {
91352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91353       };
91354     } catch (std::exception& e) {
91355       {
91356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91357       };
91358     } catch (Dali::DaliException e) {
91359       {
91360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91361       };
91362     } catch (...) {
91363       {
91364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91365       };
91366     }
91367   }
91368
91369 }
91370
91371
91372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
91373   void * jresult ;
91374   std::vector< unsigned int > *result = 0 ;
91375
91376   {
91377     try {
91378       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
91379     } catch (std::out_of_range& e) {
91380       {
91381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91382       };
91383     } catch (std::exception& e) {
91384       {
91385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91386       };
91387     } catch (Dali::DaliException e) {
91388       {
91389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91390       };
91391     } catch (...) {
91392       {
91393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91394       };
91395     }
91396   }
91397
91398   jresult = (void *)result;
91399   return jresult;
91400 }
91401
91402
91403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
91404   void * jresult ;
91405   std::vector< unsigned int > *arg1 = 0 ;
91406   std::vector< unsigned int > *result = 0 ;
91407
91408   arg1 = (std::vector< unsigned int > *)jarg1;
91409   if (!arg1) {
91410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91411     return 0;
91412   }
91413   {
91414     try {
91415       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
91416     } catch (std::out_of_range& e) {
91417       {
91418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91419       };
91420     } catch (std::exception& e) {
91421       {
91422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91423       };
91424     } catch (Dali::DaliException e) {
91425       {
91426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91427       };
91428     } catch (...) {
91429       {
91430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91431       };
91432     }
91433   }
91434
91435   jresult = (void *)result;
91436   return jresult;
91437 }
91438
91439
91440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
91441   void * jresult ;
91442   int arg1 ;
91443   std::vector< unsigned int > *result = 0 ;
91444
91445   arg1 = (int)jarg1;
91446   {
91447     try {
91448       try {
91449         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
91450       }
91451       catch(std::out_of_range &_e) {
91452         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91453         return 0;
91454       }
91455
91456     } catch (std::out_of_range& e) {
91457       {
91458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91459       };
91460     } catch (std::exception& e) {
91461       {
91462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91463       };
91464     } catch (Dali::DaliException e) {
91465       {
91466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91467       };
91468     } catch (...) {
91469       {
91470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91471       };
91472     }
91473   }
91474
91475   jresult = (void *)result;
91476   return jresult;
91477 }
91478
91479
91480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
91481   unsigned int jresult ;
91482   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91483   int arg2 ;
91484   unsigned int result;
91485
91486   arg1 = (std::vector< unsigned int > *)jarg1;
91487   arg2 = (int)jarg2;
91488   {
91489     try {
91490       try {
91491         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
91492       }
91493       catch(std::out_of_range &_e) {
91494         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91495         return 0;
91496       }
91497
91498     } catch (std::out_of_range& e) {
91499       {
91500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91501       };
91502     } catch (std::exception& e) {
91503       {
91504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91505       };
91506     } catch (Dali::DaliException e) {
91507       {
91508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91509       };
91510     } catch (...) {
91511       {
91512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91513       };
91514     }
91515   }
91516
91517   jresult = result;
91518   return jresult;
91519 }
91520
91521
91522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
91523   unsigned int jresult ;
91524   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91525   int arg2 ;
91526   unsigned int *result = 0 ;
91527
91528   arg1 = (std::vector< unsigned int > *)jarg1;
91529   arg2 = (int)jarg2;
91530   {
91531     try {
91532       try {
91533         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
91534       }
91535       catch(std::out_of_range &_e) {
91536         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91537         return 0;
91538       }
91539
91540     } catch (std::out_of_range& e) {
91541       {
91542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91543       };
91544     } catch (std::exception& e) {
91545       {
91546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91547       };
91548     } catch (Dali::DaliException e) {
91549       {
91550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91551       };
91552     } catch (...) {
91553       {
91554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91555       };
91556     }
91557   }
91558
91559   jresult = *result;
91560   return jresult;
91561 }
91562
91563
91564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
91565   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91566   int arg2 ;
91567   unsigned int *arg3 = 0 ;
91568   unsigned int temp3 ;
91569
91570   arg1 = (std::vector< unsigned int > *)jarg1;
91571   arg2 = (int)jarg2;
91572   temp3 = (unsigned int)jarg3;
91573   arg3 = &temp3;
91574   {
91575     try {
91576       try {
91577         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
91578       }
91579       catch(std::out_of_range &_e) {
91580         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91581         return ;
91582       }
91583
91584     } catch (std::out_of_range& e) {
91585       {
91586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91587       };
91588     } catch (std::exception& e) {
91589       {
91590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91591       };
91592     } catch (Dali::DaliException e) {
91593       {
91594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91595       };
91596     } catch (...) {
91597       {
91598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91599       };
91600     }
91601   }
91602
91603 }
91604
91605
91606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
91607   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91608   std::vector< unsigned int > *arg2 = 0 ;
91609
91610   arg1 = (std::vector< unsigned int > *)jarg1;
91611   arg2 = (std::vector< unsigned int > *)jarg2;
91612   if (!arg2) {
91613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91614     return ;
91615   }
91616   {
91617     try {
91618       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
91619     } catch (std::out_of_range& e) {
91620       {
91621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91622       };
91623     } catch (std::exception& e) {
91624       {
91625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91626       };
91627     } catch (Dali::DaliException e) {
91628       {
91629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91630       };
91631     } catch (...) {
91632       {
91633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91634       };
91635     }
91636   }
91637
91638 }
91639
91640
91641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
91642   void * jresult ;
91643   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91644   int arg2 ;
91645   int arg3 ;
91646   std::vector< unsigned int > *result = 0 ;
91647
91648   arg1 = (std::vector< unsigned int > *)jarg1;
91649   arg2 = (int)jarg2;
91650   arg3 = (int)jarg3;
91651   {
91652     try {
91653       try {
91654         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
91655       }
91656       catch(std::out_of_range &_e) {
91657         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91658         return 0;
91659       }
91660       catch(std::invalid_argument &_e) {
91661         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91662         return 0;
91663       }
91664
91665     } catch (std::out_of_range& e) {
91666       {
91667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91668       };
91669     } catch (std::exception& e) {
91670       {
91671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91672       };
91673     } catch (Dali::DaliException e) {
91674       {
91675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91676       };
91677     } catch (...) {
91678       {
91679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91680       };
91681     }
91682   }
91683
91684   jresult = (void *)result;
91685   return jresult;
91686 }
91687
91688
91689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
91690   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91691   int arg2 ;
91692   unsigned int *arg3 = 0 ;
91693   unsigned int temp3 ;
91694
91695   arg1 = (std::vector< unsigned int > *)jarg1;
91696   arg2 = (int)jarg2;
91697   temp3 = (unsigned int)jarg3;
91698   arg3 = &temp3;
91699   {
91700     try {
91701       try {
91702         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
91703       }
91704       catch(std::out_of_range &_e) {
91705         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91706         return ;
91707       }
91708
91709     } catch (std::out_of_range& e) {
91710       {
91711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91712       };
91713     } catch (std::exception& e) {
91714       {
91715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91716       };
91717     } catch (Dali::DaliException e) {
91718       {
91719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91720       };
91721     } catch (...) {
91722       {
91723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91724       };
91725     }
91726   }
91727
91728 }
91729
91730
91731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
91732   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91733   int arg2 ;
91734   std::vector< unsigned int > *arg3 = 0 ;
91735
91736   arg1 = (std::vector< unsigned int > *)jarg1;
91737   arg2 = (int)jarg2;
91738   arg3 = (std::vector< unsigned int > *)jarg3;
91739   if (!arg3) {
91740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91741     return ;
91742   }
91743   {
91744     try {
91745       try {
91746         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
91747       }
91748       catch(std::out_of_range &_e) {
91749         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91750         return ;
91751       }
91752
91753     } catch (std::out_of_range& e) {
91754       {
91755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91756       };
91757     } catch (std::exception& e) {
91758       {
91759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91760       };
91761     } catch (Dali::DaliException e) {
91762       {
91763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91764       };
91765     } catch (...) {
91766       {
91767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91768       };
91769     }
91770   }
91771
91772 }
91773
91774
91775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
91776   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91777   int arg2 ;
91778
91779   arg1 = (std::vector< unsigned int > *)jarg1;
91780   arg2 = (int)jarg2;
91781   {
91782     try {
91783       try {
91784         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
91785       }
91786       catch(std::out_of_range &_e) {
91787         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91788         return ;
91789       }
91790
91791     } catch (std::out_of_range& e) {
91792       {
91793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91794       };
91795     } catch (std::exception& e) {
91796       {
91797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91798       };
91799     } catch (Dali::DaliException e) {
91800       {
91801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91802       };
91803     } catch (...) {
91804       {
91805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91806       };
91807     }
91808   }
91809
91810 }
91811
91812
91813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
91814   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91815   int arg2 ;
91816   int arg3 ;
91817
91818   arg1 = (std::vector< unsigned int > *)jarg1;
91819   arg2 = (int)jarg2;
91820   arg3 = (int)jarg3;
91821   {
91822     try {
91823       try {
91824         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
91825       }
91826       catch(std::out_of_range &_e) {
91827         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91828         return ;
91829       }
91830       catch(std::invalid_argument &_e) {
91831         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91832         return ;
91833       }
91834
91835     } catch (std::out_of_range& e) {
91836       {
91837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91838       };
91839     } catch (std::exception& e) {
91840       {
91841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91842       };
91843     } catch (Dali::DaliException e) {
91844       {
91845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91846       };
91847     } catch (...) {
91848       {
91849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91850       };
91851     }
91852   }
91853
91854 }
91855
91856
91857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
91858   void * jresult ;
91859   unsigned int *arg1 = 0 ;
91860   int arg2 ;
91861   unsigned int temp1 ;
91862   std::vector< unsigned int > *result = 0 ;
91863
91864   temp1 = (unsigned int)jarg1;
91865   arg1 = &temp1;
91866   arg2 = (int)jarg2;
91867   {
91868     try {
91869       try {
91870         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
91871       }
91872       catch(std::out_of_range &_e) {
91873         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91874         return 0;
91875       }
91876
91877     } catch (std::out_of_range& e) {
91878       {
91879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91880       };
91881     } catch (std::exception& e) {
91882       {
91883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91884       };
91885     } catch (Dali::DaliException e) {
91886       {
91887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91888       };
91889     } catch (...) {
91890       {
91891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91892       };
91893     }
91894   }
91895
91896   jresult = (void *)result;
91897   return jresult;
91898 }
91899
91900
91901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
91902   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91903
91904   arg1 = (std::vector< unsigned int > *)jarg1;
91905   {
91906     try {
91907       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
91908     } catch (std::out_of_range& e) {
91909       {
91910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91911       };
91912     } catch (std::exception& e) {
91913       {
91914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91915       };
91916     } catch (Dali::DaliException e) {
91917       {
91918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91919       };
91920     } catch (...) {
91921       {
91922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91923       };
91924     }
91925   }
91926
91927 }
91928
91929
91930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
91931   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91932   int arg2 ;
91933   int arg3 ;
91934
91935   arg1 = (std::vector< unsigned int > *)jarg1;
91936   arg2 = (int)jarg2;
91937   arg3 = (int)jarg3;
91938   {
91939     try {
91940       try {
91941         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
91942       }
91943       catch(std::out_of_range &_e) {
91944         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91945         return ;
91946       }
91947       catch(std::invalid_argument &_e) {
91948         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91949         return ;
91950       }
91951
91952     } catch (std::out_of_range& e) {
91953       {
91954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91955       };
91956     } catch (std::exception& e) {
91957       {
91958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91959       };
91960     } catch (Dali::DaliException e) {
91961       {
91962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91963       };
91964     } catch (...) {
91965       {
91966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91967       };
91968     }
91969   }
91970
91971 }
91972
91973
91974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
91975   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91976   int arg2 ;
91977   std::vector< unsigned int > *arg3 = 0 ;
91978
91979   arg1 = (std::vector< unsigned int > *)jarg1;
91980   arg2 = (int)jarg2;
91981   arg3 = (std::vector< unsigned int > *)jarg3;
91982   if (!arg3) {
91983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91984     return ;
91985   }
91986   {
91987     try {
91988       try {
91989         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
91990       }
91991       catch(std::out_of_range &_e) {
91992         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91993         return ;
91994       }
91995
91996     } catch (std::out_of_range& e) {
91997       {
91998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91999       };
92000     } catch (std::exception& e) {
92001       {
92002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92003       };
92004     } catch (Dali::DaliException e) {
92005       {
92006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92007       };
92008     } catch (...) {
92009       {
92010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92011       };
92012     }
92013   }
92014
92015 }
92016
92017
92018 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
92019   unsigned int jresult ;
92020   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92021   unsigned int *arg2 = 0 ;
92022   unsigned int temp2 ;
92023   bool result;
92024
92025   arg1 = (std::vector< unsigned int > *)jarg1;
92026   temp2 = (unsigned int)jarg2;
92027   arg2 = &temp2;
92028   {
92029     try {
92030       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
92031     } catch (std::out_of_range& e) {
92032       {
92033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92034       };
92035     } catch (std::exception& e) {
92036       {
92037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92038       };
92039     } catch (Dali::DaliException e) {
92040       {
92041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92042       };
92043     } catch (...) {
92044       {
92045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92046       };
92047     }
92048   }
92049
92050   jresult = result;
92051   return jresult;
92052 }
92053
92054
92055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
92056   int jresult ;
92057   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92058   unsigned int *arg2 = 0 ;
92059   unsigned int temp2 ;
92060   int result;
92061
92062   arg1 = (std::vector< unsigned int > *)jarg1;
92063   temp2 = (unsigned int)jarg2;
92064   arg2 = &temp2;
92065   {
92066     try {
92067       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
92068     } catch (std::out_of_range& e) {
92069       {
92070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92071       };
92072     } catch (std::exception& e) {
92073       {
92074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92075       };
92076     } catch (Dali::DaliException e) {
92077       {
92078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92079       };
92080     } catch (...) {
92081       {
92082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92083       };
92084     }
92085   }
92086
92087   jresult = result;
92088   return jresult;
92089 }
92090
92091
92092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
92093   int jresult ;
92094   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92095   unsigned int *arg2 = 0 ;
92096   unsigned int temp2 ;
92097   int result;
92098
92099   arg1 = (std::vector< unsigned int > *)jarg1;
92100   temp2 = (unsigned int)jarg2;
92101   arg2 = &temp2;
92102   {
92103     try {
92104       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
92105     } catch (std::out_of_range& e) {
92106       {
92107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92108       };
92109     } catch (std::exception& e) {
92110       {
92111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92112       };
92113     } catch (Dali::DaliException e) {
92114       {
92115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92116       };
92117     } catch (...) {
92118       {
92119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92120       };
92121     }
92122   }
92123
92124   jresult = result;
92125   return jresult;
92126 }
92127
92128
92129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
92130   unsigned int jresult ;
92131   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92132   unsigned int *arg2 = 0 ;
92133   unsigned int temp2 ;
92134   bool result;
92135
92136   arg1 = (std::vector< unsigned int > *)jarg1;
92137   temp2 = (unsigned int)jarg2;
92138   arg2 = &temp2;
92139   {
92140     try {
92141       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
92142     } catch (std::out_of_range& e) {
92143       {
92144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92145       };
92146     } catch (std::exception& e) {
92147       {
92148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92149       };
92150     } catch (Dali::DaliException e) {
92151       {
92152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92153       };
92154     } catch (...) {
92155       {
92156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92157       };
92158     }
92159   }
92160
92161   jresult = result;
92162   return jresult;
92163 }
92164
92165
92166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
92167   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92168
92169   arg1 = (std::vector< unsigned int > *)jarg1;
92170   {
92171     try {
92172       delete arg1;
92173     } catch (std::out_of_range& e) {
92174       {
92175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92176       };
92177     } catch (std::exception& e) {
92178       {
92179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92180       };
92181     } catch (Dali::DaliException e) {
92182       {
92183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92184       };
92185     } catch (...) {
92186       {
92187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92188       };
92189     }
92190   }
92191
92192 }
92193
92194
92195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
92196   void * jresult ;
92197   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92198
92199   {
92200     try {
92201       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
92202     } catch (std::out_of_range& e) {
92203       {
92204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92205       };
92206     } catch (std::exception& e) {
92207       {
92208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92209       };
92210     } catch (Dali::DaliException e) {
92211       {
92212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92213       };
92214     } catch (...) {
92215       {
92216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92217       };
92218     }
92219   }
92220
92221   jresult = (void *)result;
92222   return jresult;
92223 }
92224
92225
92226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
92227   void * jresult ;
92228   unsigned int arg1 ;
92229   Dali::Actor arg2 ;
92230   Dali::Actor *argp2 ;
92231   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92232
92233   arg1 = (unsigned int)jarg1;
92234   argp2 = (Dali::Actor *)jarg2;
92235   if (!argp2) {
92236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92237     return 0;
92238   }
92239   arg2 = *argp2;
92240   {
92241     try {
92242       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
92243     } catch (std::out_of_range& e) {
92244       {
92245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92246       };
92247     } catch (std::exception& e) {
92248       {
92249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92250       };
92251     } catch (Dali::DaliException e) {
92252       {
92253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92254       };
92255     } catch (...) {
92256       {
92257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92258       };
92259     }
92260   }
92261
92262   jresult = (void *)result;
92263   return jresult;
92264 }
92265
92266
92267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
92268   void * jresult ;
92269   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
92270   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92271
92272   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92273   if (!arg1) {
92274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92275     return 0;
92276   }
92277   {
92278     try {
92279       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
92280     } catch (std::out_of_range& e) {
92281       {
92282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92283       };
92284     } catch (std::exception& e) {
92285       {
92286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92287       };
92288     } catch (Dali::DaliException e) {
92289       {
92290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92291       };
92292     } catch (...) {
92293       {
92294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92295       };
92296     }
92297   }
92298
92299   jresult = (void *)result;
92300   return jresult;
92301 }
92302
92303
92304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
92305   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92306   unsigned int arg2 ;
92307
92308   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92309   arg2 = (unsigned int)jarg2;
92310   if (arg1) (arg1)->first = arg2;
92311 }
92312
92313
92314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
92315   unsigned int jresult ;
92316   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92317   unsigned int result;
92318
92319   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92320   result = (unsigned int) ((arg1)->first);
92321   jresult = result;
92322   return jresult;
92323 }
92324
92325
92326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
92327   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92328   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
92329
92330   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92331   arg2 = (Dali::Actor *)jarg2;
92332   if (arg1) (arg1)->second = *arg2;
92333 }
92334
92335
92336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
92337   void * jresult ;
92338   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92339   Dali::Actor *result = 0 ;
92340
92341   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92342   result = (Dali::Actor *)& ((arg1)->second);
92343   jresult = (void *)result;
92344   return jresult;
92345 }
92346
92347
92348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
92349   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92350
92351   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92352   {
92353     try {
92354       delete arg1;
92355     } catch (std::out_of_range& e) {
92356       {
92357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92358       };
92359     } catch (std::exception& e) {
92360       {
92361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92362       };
92363     } catch (Dali::DaliException e) {
92364       {
92365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92366       };
92367     } catch (...) {
92368       {
92369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92370       };
92371     }
92372   }
92373
92374 }
92375
92376
92377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
92378   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92379
92380   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92381   {
92382     try {
92383       (arg1)->clear();
92384     } catch (std::out_of_range& e) {
92385       {
92386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92387       };
92388     } catch (std::exception& e) {
92389       {
92390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92391       };
92392     } catch (Dali::DaliException e) {
92393       {
92394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92395       };
92396     } catch (...) {
92397       {
92398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92399       };
92400     }
92401   }
92402
92403 }
92404
92405
92406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
92407   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92408   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
92409
92410   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92411   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
92412   if (!arg2) {
92413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92414     return ;
92415   }
92416   {
92417     try {
92418       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
92419     } catch (std::out_of_range& e) {
92420       {
92421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92422       };
92423     } catch (std::exception& e) {
92424       {
92425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92426       };
92427     } catch (Dali::DaliException e) {
92428       {
92429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92430       };
92431     } catch (...) {
92432       {
92433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92434       };
92435     }
92436   }
92437
92438 }
92439
92440
92441 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
92442   unsigned long jresult ;
92443   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92444   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92445
92446   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92447   {
92448     try {
92449       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
92450     } catch (std::out_of_range& e) {
92451       {
92452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92453       };
92454     } catch (std::exception& e) {
92455       {
92456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92457       };
92458     } catch (Dali::DaliException e) {
92459       {
92460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92461       };
92462     } catch (...) {
92463       {
92464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92465       };
92466     }
92467   }
92468
92469   jresult = (unsigned long)result;
92470   return jresult;
92471 }
92472
92473
92474 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
92475   unsigned long jresult ;
92476   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92477   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92478
92479   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92480   {
92481     try {
92482       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
92483     } catch (std::out_of_range& e) {
92484       {
92485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92486       };
92487     } catch (std::exception& e) {
92488       {
92489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92490       };
92491     } catch (Dali::DaliException e) {
92492       {
92493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92494       };
92495     } catch (...) {
92496       {
92497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92498       };
92499     }
92500   }
92501
92502   jresult = (unsigned long)result;
92503   return jresult;
92504 }
92505
92506
92507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
92508   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92509   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
92510
92511   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92512   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
92513   {
92514     try {
92515       (arg1)->reserve(arg2);
92516     } catch (std::out_of_range& e) {
92517       {
92518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92519       };
92520     } catch (std::exception& e) {
92521       {
92522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92523       };
92524     } catch (Dali::DaliException e) {
92525       {
92526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92527       };
92528     } catch (...) {
92529       {
92530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92531       };
92532     }
92533   }
92534
92535 }
92536
92537
92538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
92539   void * jresult ;
92540   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92541
92542   {
92543     try {
92544       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
92545     } catch (std::out_of_range& e) {
92546       {
92547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92548       };
92549     } catch (std::exception& e) {
92550       {
92551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92552       };
92553     } catch (Dali::DaliException e) {
92554       {
92555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92556       };
92557     } catch (...) {
92558       {
92559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92560       };
92561     }
92562   }
92563
92564   jresult = (void *)result;
92565   return jresult;
92566 }
92567
92568
92569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
92570   void * jresult ;
92571   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
92572   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92573
92574   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92575   if (!arg1) {
92576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92577     return 0;
92578   }
92579   {
92580     try {
92581       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);
92582     } catch (std::out_of_range& e) {
92583       {
92584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92585       };
92586     } catch (std::exception& e) {
92587       {
92588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92589       };
92590     } catch (Dali::DaliException e) {
92591       {
92592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92593       };
92594     } catch (...) {
92595       {
92596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92597       };
92598     }
92599   }
92600
92601   jresult = (void *)result;
92602   return jresult;
92603 }
92604
92605
92606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
92607   void * jresult ;
92608   int arg1 ;
92609   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92610
92611   arg1 = (int)jarg1;
92612   {
92613     try {
92614       try {
92615         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);
92616       }
92617       catch(std::out_of_range &_e) {
92618         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92619         return 0;
92620       }
92621
92622     } catch (std::out_of_range& e) {
92623       {
92624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92625       };
92626     } catch (std::exception& e) {
92627       {
92628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92629       };
92630     } catch (Dali::DaliException e) {
92631       {
92632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92633       };
92634     } catch (...) {
92635       {
92636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92637       };
92638     }
92639   }
92640
92641   jresult = (void *)result;
92642   return jresult;
92643 }
92644
92645
92646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
92647   void * jresult ;
92648   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92649   int arg2 ;
92650   std::pair< unsigned int,Dali::Actor > result;
92651
92652   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92653   arg2 = (int)jarg2;
92654   {
92655     try {
92656       try {
92657         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
92658       }
92659       catch(std::out_of_range &_e) {
92660         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92661         return 0;
92662       }
92663
92664     } catch (std::out_of_range& e) {
92665       {
92666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92667       };
92668     } catch (std::exception& e) {
92669       {
92670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92671       };
92672     } catch (Dali::DaliException e) {
92673       {
92674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92675       };
92676     } catch (...) {
92677       {
92678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92679       };
92680     }
92681   }
92682
92683   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
92684   return jresult;
92685 }
92686
92687
92688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
92689   void * jresult ;
92690   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92691   int arg2 ;
92692   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92693
92694   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92695   arg2 = (int)jarg2;
92696   {
92697     try {
92698       try {
92699         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
92700       }
92701       catch(std::out_of_range &_e) {
92702         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92703         return 0;
92704       }
92705
92706     } catch (std::out_of_range& e) {
92707       {
92708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92709       };
92710     } catch (std::exception& e) {
92711       {
92712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92713       };
92714     } catch (Dali::DaliException e) {
92715       {
92716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92717       };
92718     } catch (...) {
92719       {
92720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92721       };
92722     }
92723   }
92724
92725   jresult = (void *)result;
92726   return jresult;
92727 }
92728
92729
92730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
92731   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92732   int arg2 ;
92733   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
92734
92735   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92736   arg2 = (int)jarg2;
92737   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
92738   if (!arg3) {
92739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92740     return ;
92741   }
92742   {
92743     try {
92744       try {
92745         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);
92746       }
92747       catch(std::out_of_range &_e) {
92748         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92749         return ;
92750       }
92751
92752     } catch (std::out_of_range& e) {
92753       {
92754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92755       };
92756     } catch (std::exception& e) {
92757       {
92758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92759       };
92760     } catch (Dali::DaliException e) {
92761       {
92762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92763       };
92764     } catch (...) {
92765       {
92766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92767       };
92768     }
92769   }
92770
92771 }
92772
92773
92774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
92775   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92776   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
92777
92778   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92779   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
92780   if (!arg2) {
92781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92782     return ;
92783   }
92784   {
92785     try {
92786       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);
92787     } catch (std::out_of_range& e) {
92788       {
92789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92790       };
92791     } catch (std::exception& e) {
92792       {
92793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92794       };
92795     } catch (Dali::DaliException e) {
92796       {
92797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92798       };
92799     } catch (...) {
92800       {
92801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92802       };
92803     }
92804   }
92805
92806 }
92807
92808
92809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92810   void * jresult ;
92811   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92812   int arg2 ;
92813   int arg3 ;
92814   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92815
92816   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92817   arg2 = (int)jarg2;
92818   arg3 = (int)jarg3;
92819   {
92820     try {
92821       try {
92822         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);
92823       }
92824       catch(std::out_of_range &_e) {
92825         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92826         return 0;
92827       }
92828       catch(std::invalid_argument &_e) {
92829         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92830         return 0;
92831       }
92832
92833     } catch (std::out_of_range& e) {
92834       {
92835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92836       };
92837     } catch (std::exception& e) {
92838       {
92839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92840       };
92841     } catch (Dali::DaliException e) {
92842       {
92843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92844       };
92845     } catch (...) {
92846       {
92847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92848       };
92849     }
92850   }
92851
92852   jresult = (void *)result;
92853   return jresult;
92854 }
92855
92856
92857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
92858   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92859   int arg2 ;
92860   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
92861
92862   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92863   arg2 = (int)jarg2;
92864   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
92865   if (!arg3) {
92866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92867     return ;
92868   }
92869   {
92870     try {
92871       try {
92872         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);
92873       }
92874       catch(std::out_of_range &_e) {
92875         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92876         return ;
92877       }
92878
92879     } catch (std::out_of_range& e) {
92880       {
92881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92882       };
92883     } catch (std::exception& e) {
92884       {
92885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92886       };
92887     } catch (Dali::DaliException e) {
92888       {
92889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92890       };
92891     } catch (...) {
92892       {
92893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92894       };
92895     }
92896   }
92897
92898 }
92899
92900
92901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
92902   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92903   int arg2 ;
92904   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
92905
92906   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92907   arg2 = (int)jarg2;
92908   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
92909   if (!arg3) {
92910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92911     return ;
92912   }
92913   {
92914     try {
92915       try {
92916         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);
92917       }
92918       catch(std::out_of_range &_e) {
92919         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92920         return ;
92921       }
92922
92923     } catch (std::out_of_range& e) {
92924       {
92925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92926       };
92927     } catch (std::exception& e) {
92928       {
92929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92930       };
92931     } catch (Dali::DaliException e) {
92932       {
92933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92934       };
92935     } catch (...) {
92936       {
92937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92938       };
92939     }
92940   }
92941
92942 }
92943
92944
92945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
92946   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92947   int arg2 ;
92948
92949   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92950   arg2 = (int)jarg2;
92951   {
92952     try {
92953       try {
92954         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
92955       }
92956       catch(std::out_of_range &_e) {
92957         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92958         return ;
92959       }
92960
92961     } catch (std::out_of_range& e) {
92962       {
92963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92964       };
92965     } catch (std::exception& e) {
92966       {
92967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92968       };
92969     } catch (Dali::DaliException e) {
92970       {
92971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92972       };
92973     } catch (...) {
92974       {
92975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92976       };
92977     }
92978   }
92979
92980 }
92981
92982
92983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
92984   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92985   int arg2 ;
92986   int arg3 ;
92987
92988   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92989   arg2 = (int)jarg2;
92990   arg3 = (int)jarg3;
92991   {
92992     try {
92993       try {
92994         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
92995       }
92996       catch(std::out_of_range &_e) {
92997         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92998         return ;
92999       }
93000       catch(std::invalid_argument &_e) {
93001         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93002         return ;
93003       }
93004
93005     } catch (std::out_of_range& e) {
93006       {
93007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93008       };
93009     } catch (std::exception& e) {
93010       {
93011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93012       };
93013     } catch (Dali::DaliException e) {
93014       {
93015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93016       };
93017     } catch (...) {
93018       {
93019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93020       };
93021     }
93022   }
93023
93024 }
93025
93026
93027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
93028   void * jresult ;
93029   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93030   int arg2 ;
93031   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93032
93033   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93034   if (!arg1) {
93035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93036     return 0;
93037   }
93038   arg2 = (int)jarg2;
93039   {
93040     try {
93041       try {
93042         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);
93043       }
93044       catch(std::out_of_range &_e) {
93045         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93046         return 0;
93047       }
93048
93049     } catch (std::out_of_range& e) {
93050       {
93051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93052       };
93053     } catch (std::exception& e) {
93054       {
93055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93056       };
93057     } catch (Dali::DaliException e) {
93058       {
93059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93060       };
93061     } catch (...) {
93062       {
93063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93064       };
93065     }
93066   }
93067
93068   jresult = (void *)result;
93069   return jresult;
93070 }
93071
93072
93073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
93074   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93075
93076   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93077   {
93078     try {
93079       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
93080     } catch (std::out_of_range& e) {
93081       {
93082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93083       };
93084     } catch (std::exception& e) {
93085       {
93086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93087       };
93088     } catch (Dali::DaliException e) {
93089       {
93090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93091       };
93092     } catch (...) {
93093       {
93094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93095       };
93096     }
93097   }
93098
93099 }
93100
93101
93102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93103   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93104   int arg2 ;
93105   int arg3 ;
93106
93107   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93108   arg2 = (int)jarg2;
93109   arg3 = (int)jarg3;
93110   {
93111     try {
93112       try {
93113         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93114       }
93115       catch(std::out_of_range &_e) {
93116         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93117         return ;
93118       }
93119       catch(std::invalid_argument &_e) {
93120         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93121         return ;
93122       }
93123
93124     } catch (std::out_of_range& e) {
93125       {
93126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93127       };
93128     } catch (std::exception& e) {
93129       {
93130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93131       };
93132     } catch (Dali::DaliException e) {
93133       {
93134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93135       };
93136     } catch (...) {
93137       {
93138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93139       };
93140     }
93141   }
93142
93143 }
93144
93145
93146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93147   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93148   int arg2 ;
93149   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93150
93151   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93152   arg2 = (int)jarg2;
93153   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93154   if (!arg3) {
93155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93156     return ;
93157   }
93158   {
93159     try {
93160       try {
93161         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);
93162       }
93163       catch(std::out_of_range &_e) {
93164         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93165         return ;
93166       }
93167
93168     } catch (std::out_of_range& e) {
93169       {
93170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93171       };
93172     } catch (std::exception& e) {
93173       {
93174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93175       };
93176     } catch (Dali::DaliException e) {
93177       {
93178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93179       };
93180     } catch (...) {
93181       {
93182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93183       };
93184     }
93185   }
93186
93187 }
93188
93189
93190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
93191   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93192
93193   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93194   {
93195     try {
93196       delete arg1;
93197     } catch (std::out_of_range& e) {
93198       {
93199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93200       };
93201     } catch (std::exception& e) {
93202       {
93203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93204       };
93205     } catch (Dali::DaliException e) {
93206       {
93207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93208       };
93209     } catch (...) {
93210       {
93211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93212       };
93213     }
93214   }
93215
93216 }
93217
93218
93219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
93220   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93221
93222   arg1 = (std::vector< Dali::Actor > *)jarg1;
93223   {
93224     try {
93225       (arg1)->clear();
93226     } catch (std::out_of_range& e) {
93227       {
93228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93229       };
93230     } catch (std::exception& e) {
93231       {
93232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93233       };
93234     } catch (Dali::DaliException e) {
93235       {
93236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93237       };
93238     } catch (...) {
93239       {
93240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93241       };
93242     }
93243   }
93244
93245 }
93246
93247
93248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
93249   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93250   Dali::Actor *arg2 = 0 ;
93251
93252   arg1 = (std::vector< Dali::Actor > *)jarg1;
93253   arg2 = (Dali::Actor *)jarg2;
93254   if (!arg2) {
93255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93256     return ;
93257   }
93258   {
93259     try {
93260       (arg1)->push_back((Dali::Actor const &)*arg2);
93261     } catch (std::out_of_range& e) {
93262       {
93263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93264       };
93265     } catch (std::exception& e) {
93266       {
93267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93268       };
93269     } catch (Dali::DaliException e) {
93270       {
93271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93272       };
93273     } catch (...) {
93274       {
93275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93276       };
93277     }
93278   }
93279
93280 }
93281
93282
93283 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
93284   unsigned long jresult ;
93285   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93286   std::vector< Dali::Actor >::size_type result;
93287
93288   arg1 = (std::vector< Dali::Actor > *)jarg1;
93289   {
93290     try {
93291       result = ((std::vector< Dali::Actor > const *)arg1)->size();
93292     } catch (std::out_of_range& e) {
93293       {
93294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93295       };
93296     } catch (std::exception& e) {
93297       {
93298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93299       };
93300     } catch (Dali::DaliException e) {
93301       {
93302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93303       };
93304     } catch (...) {
93305       {
93306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93307       };
93308     }
93309   }
93310
93311   jresult = (unsigned long)result;
93312   return jresult;
93313 }
93314
93315
93316 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
93317   unsigned long jresult ;
93318   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93319   std::vector< Dali::Actor >::size_type result;
93320
93321   arg1 = (std::vector< Dali::Actor > *)jarg1;
93322   {
93323     try {
93324       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
93325     } catch (std::out_of_range& e) {
93326       {
93327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93328       };
93329     } catch (std::exception& e) {
93330       {
93331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93332       };
93333     } catch (Dali::DaliException e) {
93334       {
93335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93336       };
93337     } catch (...) {
93338       {
93339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93340       };
93341     }
93342   }
93343
93344   jresult = (unsigned long)result;
93345   return jresult;
93346 }
93347
93348
93349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
93350   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93351   std::vector< Dali::Actor >::size_type arg2 ;
93352
93353   arg1 = (std::vector< Dali::Actor > *)jarg1;
93354   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
93355   {
93356     try {
93357       (arg1)->reserve(arg2);
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_new_ActorContainer__SWIG_0() {
93381   void * jresult ;
93382   std::vector< Dali::Actor > *result = 0 ;
93383
93384   {
93385     try {
93386       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
93387     } catch (std::out_of_range& e) {
93388       {
93389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93390       };
93391     } catch (std::exception& e) {
93392       {
93393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93394       };
93395     } catch (Dali::DaliException e) {
93396       {
93397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93398       };
93399     } catch (...) {
93400       {
93401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93402       };
93403     }
93404   }
93405
93406   jresult = (void *)result;
93407   return jresult;
93408 }
93409
93410
93411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
93412   void * jresult ;
93413   std::vector< Dali::Actor > *arg1 = 0 ;
93414   std::vector< Dali::Actor > *result = 0 ;
93415
93416   arg1 = (std::vector< Dali::Actor > *)jarg1;
93417   if (!arg1) {
93418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93419     return 0;
93420   }
93421   {
93422     try {
93423       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
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 = (void *)result;
93444   return jresult;
93445 }
93446
93447
93448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
93449   void * jresult ;
93450   int arg1 ;
93451   std::vector< Dali::Actor > *result = 0 ;
93452
93453   arg1 = (int)jarg1;
93454   {
93455     try {
93456       try {
93457         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
93458       }
93459       catch(std::out_of_range &_e) {
93460         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93461         return 0;
93462       }
93463
93464     } catch (std::out_of_range& e) {
93465       {
93466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93467       };
93468     } catch (std::exception& e) {
93469       {
93470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93471       };
93472     } catch (Dali::DaliException e) {
93473       {
93474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93475       };
93476     } catch (...) {
93477       {
93478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93479       };
93480     }
93481   }
93482
93483   jresult = (void *)result;
93484   return jresult;
93485 }
93486
93487
93488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
93489   void * jresult ;
93490   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93491   int arg2 ;
93492   Dali::Actor result;
93493
93494   arg1 = (std::vector< Dali::Actor > *)jarg1;
93495   arg2 = (int)jarg2;
93496   {
93497     try {
93498       try {
93499         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
93500       }
93501       catch(std::out_of_range &_e) {
93502         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93503         return 0;
93504       }
93505
93506     } catch (std::out_of_range& e) {
93507       {
93508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93509       };
93510     } catch (std::exception& e) {
93511       {
93512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93513       };
93514     } catch (Dali::DaliException e) {
93515       {
93516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93517       };
93518     } catch (...) {
93519       {
93520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93521       };
93522     }
93523   }
93524
93525   jresult = new Dali::Actor((const Dali::Actor &)result);
93526   return jresult;
93527 }
93528
93529
93530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
93531   void * jresult ;
93532   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93533   int arg2 ;
93534   Dali::Actor *result = 0 ;
93535
93536   arg1 = (std::vector< Dali::Actor > *)jarg1;
93537   arg2 = (int)jarg2;
93538   {
93539     try {
93540       try {
93541         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
93542       }
93543       catch(std::out_of_range &_e) {
93544         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93545         return 0;
93546       }
93547
93548     } catch (std::out_of_range& e) {
93549       {
93550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93551       };
93552     } catch (std::exception& e) {
93553       {
93554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93555       };
93556     } catch (Dali::DaliException e) {
93557       {
93558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93559       };
93560     } catch (...) {
93561       {
93562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93563       };
93564     }
93565   }
93566
93567   jresult = (void *)result;
93568   return jresult;
93569 }
93570
93571
93572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93573   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93574   int arg2 ;
93575   Dali::Actor *arg3 = 0 ;
93576
93577   arg1 = (std::vector< Dali::Actor > *)jarg1;
93578   arg2 = (int)jarg2;
93579   arg3 = (Dali::Actor *)jarg3;
93580   if (!arg3) {
93581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93582     return ;
93583   }
93584   {
93585     try {
93586       try {
93587         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
93588       }
93589       catch(std::out_of_range &_e) {
93590         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93591         return ;
93592       }
93593
93594     } catch (std::out_of_range& e) {
93595       {
93596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93597       };
93598     } catch (std::exception& e) {
93599       {
93600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93601       };
93602     } catch (Dali::DaliException e) {
93603       {
93604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93605       };
93606     } catch (...) {
93607       {
93608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93609       };
93610     }
93611   }
93612
93613 }
93614
93615
93616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
93617   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93618   std::vector< Dali::Actor > *arg2 = 0 ;
93619
93620   arg1 = (std::vector< Dali::Actor > *)jarg1;
93621   arg2 = (std::vector< Dali::Actor > *)jarg2;
93622   if (!arg2) {
93623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93624     return ;
93625   }
93626   {
93627     try {
93628       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
93629     } catch (std::out_of_range& e) {
93630       {
93631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93632       };
93633     } catch (std::exception& e) {
93634       {
93635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93636       };
93637     } catch (Dali::DaliException e) {
93638       {
93639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93640       };
93641     } catch (...) {
93642       {
93643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93644       };
93645     }
93646   }
93647
93648 }
93649
93650
93651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93652   void * jresult ;
93653   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93654   int arg2 ;
93655   int arg3 ;
93656   std::vector< Dali::Actor > *result = 0 ;
93657
93658   arg1 = (std::vector< Dali::Actor > *)jarg1;
93659   arg2 = (int)jarg2;
93660   arg3 = (int)jarg3;
93661   {
93662     try {
93663       try {
93664         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
93665       }
93666       catch(std::out_of_range &_e) {
93667         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93668         return 0;
93669       }
93670       catch(std::invalid_argument &_e) {
93671         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93672         return 0;
93673       }
93674
93675     } catch (std::out_of_range& e) {
93676       {
93677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93678       };
93679     } catch (std::exception& e) {
93680       {
93681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93682       };
93683     } catch (Dali::DaliException e) {
93684       {
93685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93686       };
93687     } catch (...) {
93688       {
93689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93690       };
93691     }
93692   }
93693
93694   jresult = (void *)result;
93695   return jresult;
93696 }
93697
93698
93699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93700   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93701   int arg2 ;
93702   Dali::Actor *arg3 = 0 ;
93703
93704   arg1 = (std::vector< Dali::Actor > *)jarg1;
93705   arg2 = (int)jarg2;
93706   arg3 = (Dali::Actor *)jarg3;
93707   if (!arg3) {
93708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93709     return ;
93710   }
93711   {
93712     try {
93713       try {
93714         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
93715       }
93716       catch(std::out_of_range &_e) {
93717         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93718         return ;
93719       }
93720
93721     } catch (std::out_of_range& e) {
93722       {
93723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93724       };
93725     } catch (std::exception& e) {
93726       {
93727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93728       };
93729     } catch (Dali::DaliException e) {
93730       {
93731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93732       };
93733     } catch (...) {
93734       {
93735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93736       };
93737     }
93738   }
93739
93740 }
93741
93742
93743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93744   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93745   int arg2 ;
93746   std::vector< Dali::Actor > *arg3 = 0 ;
93747
93748   arg1 = (std::vector< Dali::Actor > *)jarg1;
93749   arg2 = (int)jarg2;
93750   arg3 = (std::vector< Dali::Actor > *)jarg3;
93751   if (!arg3) {
93752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93753     return ;
93754   }
93755   {
93756     try {
93757       try {
93758         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
93759       }
93760       catch(std::out_of_range &_e) {
93761         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93762         return ;
93763       }
93764
93765     } catch (std::out_of_range& e) {
93766       {
93767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93768       };
93769     } catch (std::exception& e) {
93770       {
93771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93772       };
93773     } catch (Dali::DaliException e) {
93774       {
93775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93776       };
93777     } catch (...) {
93778       {
93779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93780       };
93781     }
93782   }
93783
93784 }
93785
93786
93787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
93788   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93789   int arg2 ;
93790
93791   arg1 = (std::vector< Dali::Actor > *)jarg1;
93792   arg2 = (int)jarg2;
93793   {
93794     try {
93795       try {
93796         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
93797       }
93798       catch(std::out_of_range &_e) {
93799         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93800         return ;
93801       }
93802
93803     } catch (std::out_of_range& e) {
93804       {
93805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93806       };
93807     } catch (std::exception& e) {
93808       {
93809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93810       };
93811     } catch (Dali::DaliException e) {
93812       {
93813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93814       };
93815     } catch (...) {
93816       {
93817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93818       };
93819     }
93820   }
93821
93822 }
93823
93824
93825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93826   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93827   int arg2 ;
93828   int arg3 ;
93829
93830   arg1 = (std::vector< Dali::Actor > *)jarg1;
93831   arg2 = (int)jarg2;
93832   arg3 = (int)jarg3;
93833   {
93834     try {
93835       try {
93836         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
93837       }
93838       catch(std::out_of_range &_e) {
93839         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93840         return ;
93841       }
93842       catch(std::invalid_argument &_e) {
93843         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93844         return ;
93845       }
93846
93847     } catch (std::out_of_range& e) {
93848       {
93849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93850       };
93851     } catch (std::exception& e) {
93852       {
93853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93854       };
93855     } catch (Dali::DaliException e) {
93856       {
93857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93858       };
93859     } catch (...) {
93860       {
93861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93862       };
93863     }
93864   }
93865
93866 }
93867
93868
93869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
93870   void * jresult ;
93871   Dali::Actor *arg1 = 0 ;
93872   int arg2 ;
93873   std::vector< Dali::Actor > *result = 0 ;
93874
93875   arg1 = (Dali::Actor *)jarg1;
93876   if (!arg1) {
93877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93878     return 0;
93879   }
93880   arg2 = (int)jarg2;
93881   {
93882     try {
93883       try {
93884         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
93885       }
93886       catch(std::out_of_range &_e) {
93887         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93888         return 0;
93889       }
93890
93891     } catch (std::out_of_range& e) {
93892       {
93893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93894       };
93895     } catch (std::exception& e) {
93896       {
93897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93898       };
93899     } catch (Dali::DaliException e) {
93900       {
93901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93902       };
93903     } catch (...) {
93904       {
93905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93906       };
93907     }
93908   }
93909
93910   jresult = (void *)result;
93911   return jresult;
93912 }
93913
93914
93915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
93916   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93917
93918   arg1 = (std::vector< Dali::Actor > *)jarg1;
93919   {
93920     try {
93921       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
93922     } catch (std::out_of_range& e) {
93923       {
93924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93925       };
93926     } catch (std::exception& e) {
93927       {
93928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93929       };
93930     } catch (Dali::DaliException e) {
93931       {
93932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93933       };
93934     } catch (...) {
93935       {
93936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93937       };
93938     }
93939   }
93940
93941 }
93942
93943
93944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93945   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93946   int arg2 ;
93947   int arg3 ;
93948
93949   arg1 = (std::vector< Dali::Actor > *)jarg1;
93950   arg2 = (int)jarg2;
93951   arg3 = (int)jarg3;
93952   {
93953     try {
93954       try {
93955         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93956       }
93957       catch(std::out_of_range &_e) {
93958         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93959         return ;
93960       }
93961       catch(std::invalid_argument &_e) {
93962         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93963         return ;
93964       }
93965
93966     } catch (std::out_of_range& e) {
93967       {
93968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93969       };
93970     } catch (std::exception& e) {
93971       {
93972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93973       };
93974     } catch (Dali::DaliException e) {
93975       {
93976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93977       };
93978     } catch (...) {
93979       {
93980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93981       };
93982     }
93983   }
93984
93985 }
93986
93987
93988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93989   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93990   int arg2 ;
93991   std::vector< Dali::Actor > *arg3 = 0 ;
93992
93993   arg1 = (std::vector< Dali::Actor > *)jarg1;
93994   arg2 = (int)jarg2;
93995   arg3 = (std::vector< Dali::Actor > *)jarg3;
93996   if (!arg3) {
93997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93998     return ;
93999   }
94000   {
94001     try {
94002       try {
94003         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94004       }
94005       catch(std::out_of_range &_e) {
94006         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94007         return ;
94008       }
94009
94010     } catch (std::out_of_range& e) {
94011       {
94012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94013       };
94014     } catch (std::exception& e) {
94015       {
94016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94017       };
94018     } catch (Dali::DaliException e) {
94019       {
94020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94021       };
94022     } catch (...) {
94023       {
94024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94025       };
94026     }
94027   }
94028
94029 }
94030
94031
94032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
94033   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94034
94035   arg1 = (std::vector< Dali::Actor > *)jarg1;
94036   {
94037     try {
94038       delete arg1;
94039     } catch (std::out_of_range& e) {
94040       {
94041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94042       };
94043     } catch (std::exception& e) {
94044       {
94045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94046       };
94047     } catch (Dali::DaliException e) {
94048       {
94049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94050       };
94051     } catch (...) {
94052       {
94053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94054       };
94055     }
94056   }
94057
94058 }
94059
94060
94061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
94062   unsigned int jresult ;
94063   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94064   bool result;
94065
94066   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94067   {
94068     try {
94069       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94070     } catch (std::out_of_range& e) {
94071       {
94072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94073       };
94074     } catch (std::exception& e) {
94075       {
94076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94077       };
94078     } catch (Dali::DaliException e) {
94079       {
94080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94081       };
94082     } catch (...) {
94083       {
94084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94085       };
94086     }
94087   }
94088
94089   jresult = result;
94090   return jresult;
94091 }
94092
94093
94094 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
94095   unsigned long jresult ;
94096   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94097   std::size_t result;
94098
94099   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94100   {
94101     try {
94102       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94103     } catch (std::out_of_range& e) {
94104       {
94105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94106       };
94107     } catch (std::exception& e) {
94108       {
94109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94110       };
94111     } catch (Dali::DaliException e) {
94112       {
94113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94114       };
94115     } catch (...) {
94116       {
94117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94118       };
94119     }
94120   }
94121
94122   jresult = (unsigned long)result;
94123   return jresult;
94124 }
94125
94126
94127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
94128   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94129   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94130
94131   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94132   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94133   {
94134     try {
94135       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
94136     } catch (std::out_of_range& e) {
94137       {
94138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94139       };
94140     } catch (std::exception& e) {
94141       {
94142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94143       };
94144     } catch (Dali::DaliException e) {
94145       {
94146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94147       };
94148     } catch (...) {
94149       {
94150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94151       };
94152     }
94153   }
94154
94155 }
94156
94157
94158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
94159   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94160   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94161
94162   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94163   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94164   {
94165     try {
94166       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
94167     } catch (std::out_of_range& e) {
94168       {
94169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94170       };
94171     } catch (std::exception& e) {
94172       {
94173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94174       };
94175     } catch (Dali::DaliException e) {
94176       {
94177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94178       };
94179     } catch (...) {
94180       {
94181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94182       };
94183     }
94184   }
94185
94186 }
94187
94188
94189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
94190   unsigned int jresult ;
94191   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94192   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
94193   bool result;
94194
94195   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94196   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
94197   if (!arg2) {
94198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
94199     return 0;
94200   }
94201   {
94202     try {
94203       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
94204     } catch (std::out_of_range& e) {
94205       {
94206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94207       };
94208     } catch (std::exception& e) {
94209       {
94210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94211       };
94212     } catch (Dali::DaliException e) {
94213       {
94214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94215       };
94216     } catch (...) {
94217       {
94218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94219       };
94220     }
94221   }
94222
94223   jresult = result;
94224   return jresult;
94225 }
94226
94227
94228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
94229   void * jresult ;
94230   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
94231
94232   {
94233     try {
94234       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
94235     } catch (std::out_of_range& e) {
94236       {
94237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94238       };
94239     } catch (std::exception& e) {
94240       {
94241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94242       };
94243     } catch (Dali::DaliException e) {
94244       {
94245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94246       };
94247     } catch (...) {
94248       {
94249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94250       };
94251     }
94252   }
94253
94254   jresult = (void *)result;
94255   return jresult;
94256 }
94257
94258
94259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
94260   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94261
94262   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94263   {
94264     try {
94265       delete arg1;
94266     } catch (std::out_of_range& e) {
94267       {
94268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94269       };
94270     } catch (std::exception& e) {
94271       {
94272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94273       };
94274     } catch (Dali::DaliException e) {
94275       {
94276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94277       };
94278     } catch (...) {
94279       {
94280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94281       };
94282     }
94283   }
94284
94285 }
94286
94287
94288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
94289   unsigned int jresult ;
94290   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94291   bool result;
94292
94293   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94294   {
94295     try {
94296       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);
94297     } catch (std::out_of_range& e) {
94298       {
94299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94300       };
94301     } catch (std::exception& e) {
94302       {
94303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94304       };
94305     } catch (Dali::DaliException e) {
94306       {
94307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94308       };
94309     } catch (...) {
94310       {
94311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94312       };
94313     }
94314   }
94315
94316   jresult = result;
94317   return jresult;
94318 }
94319
94320
94321 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
94322   unsigned long jresult ;
94323   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94324   std::size_t result;
94325
94326   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94327   {
94328     try {
94329       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);
94330     } catch (std::out_of_range& e) {
94331       {
94332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94333       };
94334     } catch (std::exception& e) {
94335       {
94336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94337       };
94338     } catch (Dali::DaliException e) {
94339       {
94340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94341       };
94342     } catch (...) {
94343       {
94344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94345       };
94346     }
94347   }
94348
94349   jresult = (unsigned long)result;
94350   return jresult;
94351 }
94352
94353
94354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
94355   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94356   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94357
94358   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94359   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94360   {
94361     try {
94362       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
94363     } catch (std::out_of_range& e) {
94364       {
94365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94366       };
94367     } catch (std::exception& e) {
94368       {
94369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94370       };
94371     } catch (Dali::DaliException e) {
94372       {
94373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94374       };
94375     } catch (...) {
94376       {
94377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94378       };
94379     }
94380   }
94381
94382 }
94383
94384
94385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
94386   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94387   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94388
94389   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94390   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94391   {
94392     try {
94393       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
94394     } catch (std::out_of_range& e) {
94395       {
94396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94397       };
94398     } catch (std::exception& e) {
94399       {
94400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94401       };
94402     } catch (Dali::DaliException e) {
94403       {
94404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94405       };
94406     } catch (...) {
94407       {
94408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94409       };
94410     }
94411   }
94412
94413 }
94414
94415
94416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
94417   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94418   Dali::Actor arg2 ;
94419   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
94420   Dali::Actor *argp2 ;
94421
94422   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94423   argp2 = (Dali::Actor *)jarg2;
94424   if (!argp2) {
94425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94426     return ;
94427   }
94428   arg2 = *argp2;
94429   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
94430   {
94431     try {
94432       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
94433     } catch (std::out_of_range& e) {
94434       {
94435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94436       };
94437     } catch (std::exception& e) {
94438       {
94439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94440       };
94441     } catch (Dali::DaliException e) {
94442       {
94443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94444       };
94445     } catch (...) {
94446       {
94447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94448       };
94449     }
94450   }
94451
94452 }
94453
94454
94455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
94456   void * jresult ;
94457   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
94458
94459   {
94460     try {
94461       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
94462     } catch (std::out_of_range& e) {
94463       {
94464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94465       };
94466     } catch (std::exception& e) {
94467       {
94468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94469       };
94470     } catch (Dali::DaliException e) {
94471       {
94472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94473       };
94474     } catch (...) {
94475       {
94476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94477       };
94478     }
94479   }
94480
94481   jresult = (void *)result;
94482   return jresult;
94483 }
94484
94485
94486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
94487   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94488
94489   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94490   {
94491     try {
94492       delete arg1;
94493     } catch (std::out_of_range& e) {
94494       {
94495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94496       };
94497     } catch (std::exception& e) {
94498       {
94499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94500       };
94501     } catch (Dali::DaliException e) {
94502       {
94503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94504       };
94505     } catch (...) {
94506       {
94507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94508       };
94509     }
94510   }
94511
94512 }
94513
94514
94515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
94516   unsigned int jresult ;
94517   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94518   bool result;
94519
94520   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94521   {
94522     try {
94523       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94524     } catch (std::out_of_range& e) {
94525       {
94526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94527       };
94528     } catch (std::exception& e) {
94529       {
94530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94531       };
94532     } catch (Dali::DaliException e) {
94533       {
94534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94535       };
94536     } catch (...) {
94537       {
94538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94539       };
94540     }
94541   }
94542
94543   jresult = result;
94544   return jresult;
94545 }
94546
94547
94548 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
94549   unsigned long jresult ;
94550   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94551   std::size_t result;
94552
94553   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94554   {
94555     try {
94556       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94557     } catch (std::out_of_range& e) {
94558       {
94559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94560       };
94561     } catch (std::exception& e) {
94562       {
94563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94564       };
94565     } catch (Dali::DaliException e) {
94566       {
94567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94568       };
94569     } catch (...) {
94570       {
94571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94572       };
94573     }
94574   }
94575
94576   jresult = (unsigned long)result;
94577   return jresult;
94578 }
94579
94580
94581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
94582   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94583   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94584
94585   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94586   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94587   {
94588     try {
94589       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
94590     } catch (std::out_of_range& e) {
94591       {
94592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94593       };
94594     } catch (std::exception& e) {
94595       {
94596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94597       };
94598     } catch (Dali::DaliException e) {
94599       {
94600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94601       };
94602     } catch (...) {
94603       {
94604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94605       };
94606     }
94607   }
94608
94609 }
94610
94611
94612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94613   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94614   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94615
94616   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94617   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94618   {
94619     try {
94620       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
94621     } catch (std::out_of_range& e) {
94622       {
94623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94624       };
94625     } catch (std::exception& e) {
94626       {
94627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94628       };
94629     } catch (Dali::DaliException e) {
94630       {
94631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94632       };
94633     } catch (...) {
94634       {
94635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94636       };
94637     }
94638   }
94639
94640 }
94641
94642
94643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
94644   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94645   Dali::Actor arg2 ;
94646   Dali::Actor arg3 ;
94647   Dali::Actor *argp2 ;
94648   Dali::Actor *argp3 ;
94649
94650   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94651   argp2 = (Dali::Actor *)jarg2;
94652   if (!argp2) {
94653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94654     return ;
94655   }
94656   arg2 = *argp2;
94657   argp3 = (Dali::Actor *)jarg3;
94658   if (!argp3) {
94659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94660     return ;
94661   }
94662   arg3 = *argp3;
94663   {
94664     try {
94665       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
94666     } catch (std::out_of_range& e) {
94667       {
94668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94669       };
94670     } catch (std::exception& e) {
94671       {
94672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94673       };
94674     } catch (Dali::DaliException e) {
94675       {
94676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94677       };
94678     } catch (...) {
94679       {
94680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94681       };
94682     }
94683   }
94684
94685 }
94686
94687
94688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
94689   void * jresult ;
94690   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
94691
94692   {
94693     try {
94694       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
94695     } catch (std::out_of_range& e) {
94696       {
94697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94698       };
94699     } catch (std::exception& e) {
94700       {
94701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94702       };
94703     } catch (Dali::DaliException e) {
94704       {
94705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94706       };
94707     } catch (...) {
94708       {
94709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94710       };
94711     }
94712   }
94713
94714   jresult = (void *)result;
94715   return jresult;
94716 }
94717
94718
94719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
94720   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94721
94722   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94723   {
94724     try {
94725       delete arg1;
94726     } catch (std::out_of_range& e) {
94727       {
94728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94729       };
94730     } catch (std::exception& e) {
94731       {
94732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94733       };
94734     } catch (Dali::DaliException e) {
94735       {
94736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94737       };
94738     } catch (...) {
94739       {
94740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94741       };
94742     }
94743   }
94744
94745 }
94746
94747
94748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
94749   unsigned int jresult ;
94750   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94751   bool result;
94752
94753   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94754   {
94755     try {
94756       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94757     } catch (std::out_of_range& e) {
94758       {
94759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94760       };
94761     } catch (std::exception& e) {
94762       {
94763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94764       };
94765     } catch (Dali::DaliException e) {
94766       {
94767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94768       };
94769     } catch (...) {
94770       {
94771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94772       };
94773     }
94774   }
94775
94776   jresult = result;
94777   return jresult;
94778 }
94779
94780
94781 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
94782   unsigned long jresult ;
94783   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94784   std::size_t result;
94785
94786   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94787   {
94788     try {
94789       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94790     } catch (std::out_of_range& e) {
94791       {
94792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94793       };
94794     } catch (std::exception& e) {
94795       {
94796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94797       };
94798     } catch (Dali::DaliException e) {
94799       {
94800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94801       };
94802     } catch (...) {
94803       {
94804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94805       };
94806     }
94807   }
94808
94809   jresult = (unsigned long)result;
94810   return jresult;
94811 }
94812
94813
94814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
94815   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94816   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
94817
94818   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94819   arg2 = (void (*)(Dali::Actor,bool))jarg2;
94820   {
94821     try {
94822       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
94823     } catch (std::out_of_range& e) {
94824       {
94825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94826       };
94827     } catch (std::exception& e) {
94828       {
94829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94830       };
94831     } catch (Dali::DaliException e) {
94832       {
94833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94834       };
94835     } catch (...) {
94836       {
94837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94838       };
94839     }
94840   }
94841
94842 }
94843
94844
94845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94846   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94847   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
94848
94849   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94850   arg2 = (void (*)(Dali::Actor,bool))jarg2;
94851   {
94852     try {
94853       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
94854     } catch (std::out_of_range& e) {
94855       {
94856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94857       };
94858     } catch (std::exception& e) {
94859       {
94860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94861       };
94862     } catch (Dali::DaliException e) {
94863       {
94864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94865       };
94866     } catch (...) {
94867       {
94868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94869       };
94870     }
94871   }
94872
94873 }
94874
94875
94876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
94877   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94878   Dali::Actor arg2 ;
94879   bool arg3 ;
94880   Dali::Actor *argp2 ;
94881
94882   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94883   argp2 = (Dali::Actor *)jarg2;
94884   if (!argp2) {
94885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94886     return ;
94887   }
94888   arg2 = *argp2;
94889   arg3 = jarg3 ? true : false;
94890   {
94891     try {
94892       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
94893     } catch (std::out_of_range& e) {
94894       {
94895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94896       };
94897     } catch (std::exception& e) {
94898       {
94899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94900       };
94901     } catch (Dali::DaliException e) {
94902       {
94903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94904       };
94905     } catch (...) {
94906       {
94907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94908       };
94909     }
94910   }
94911
94912 }
94913
94914
94915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
94916   void * jresult ;
94917   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
94918
94919   {
94920     try {
94921       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
94922     } catch (std::out_of_range& e) {
94923       {
94924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94925       };
94926     } catch (std::exception& e) {
94927       {
94928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94929       };
94930     } catch (Dali::DaliException e) {
94931       {
94932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94933       };
94934     } catch (...) {
94935       {
94936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94937       };
94938     }
94939   }
94940
94941   jresult = (void *)result;
94942   return jresult;
94943 }
94944
94945
94946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
94947   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94948
94949   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94950   {
94951     try {
94952       delete arg1;
94953     } catch (std::out_of_range& e) {
94954       {
94955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94956       };
94957     } catch (std::exception& e) {
94958       {
94959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94960       };
94961     } catch (Dali::DaliException e) {
94962       {
94963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94964       };
94965     } catch (...) {
94966       {
94967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94968       };
94969     }
94970   }
94971
94972 }
94973
94974
94975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
94976   unsigned int jresult ;
94977   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
94978   bool result;
94979
94980   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
94981   {
94982     try {
94983       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);
94984     } catch (std::out_of_range& e) {
94985       {
94986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94987       };
94988     } catch (std::exception& e) {
94989       {
94990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94991       };
94992     } catch (Dali::DaliException e) {
94993       {
94994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94995       };
94996     } catch (...) {
94997       {
94998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94999       };
95000     }
95001   }
95002
95003   jresult = result;
95004   return jresult;
95005 }
95006
95007
95008 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
95009   unsigned long jresult ;
95010   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95011   std::size_t result;
95012
95013   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95014   {
95015     try {
95016       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);
95017     } catch (std::out_of_range& e) {
95018       {
95019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95020       };
95021     } catch (std::exception& e) {
95022       {
95023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95024       };
95025     } catch (Dali::DaliException e) {
95026       {
95027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95028       };
95029     } catch (...) {
95030       {
95031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95032       };
95033     }
95034   }
95035
95036   jresult = (unsigned long)result;
95037   return jresult;
95038 }
95039
95040
95041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
95042   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95043   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95044
95045   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95046   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95047   {
95048     try {
95049       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
95050     } catch (std::out_of_range& e) {
95051       {
95052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95053       };
95054     } catch (std::exception& e) {
95055       {
95056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95057       };
95058     } catch (Dali::DaliException e) {
95059       {
95060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95061       };
95062     } catch (...) {
95063       {
95064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95065       };
95066     }
95067   }
95068
95069 }
95070
95071
95072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95073   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95074   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95075
95076   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95077   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95078   {
95079     try {
95080       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
95081     } catch (std::out_of_range& e) {
95082       {
95083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95084       };
95085     } catch (std::exception& e) {
95086       {
95087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95088       };
95089     } catch (Dali::DaliException e) {
95090       {
95091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95092       };
95093     } catch (...) {
95094       {
95095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95096       };
95097     }
95098   }
95099
95100 }
95101
95102
95103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95104   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95105   Dali::Toolkit::StyleManager arg2 ;
95106   Dali::StyleChange::Type arg3 ;
95107   Dali::Toolkit::StyleManager *argp2 ;
95108
95109   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95110   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
95111   if (!argp2) {
95112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
95113     return ;
95114   }
95115   arg2 = *argp2;
95116   arg3 = (Dali::StyleChange::Type)jarg3;
95117   {
95118     try {
95119       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
95120     } catch (std::out_of_range& e) {
95121       {
95122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95123       };
95124     } catch (std::exception& e) {
95125       {
95126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95127       };
95128     } catch (Dali::DaliException e) {
95129       {
95130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95131       };
95132     } catch (...) {
95133       {
95134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95135       };
95136     }
95137   }
95138
95139 }
95140
95141
95142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
95143   void * jresult ;
95144   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
95145
95146   {
95147     try {
95148       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
95149     } catch (std::out_of_range& e) {
95150       {
95151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95152       };
95153     } catch (std::exception& e) {
95154       {
95155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95156       };
95157     } catch (Dali::DaliException e) {
95158       {
95159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95160       };
95161     } catch (...) {
95162       {
95163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95164       };
95165     }
95166   }
95167
95168   jresult = (void *)result;
95169   return jresult;
95170 }
95171
95172
95173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
95174   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95175
95176   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95177   {
95178     try {
95179       delete arg1;
95180     } catch (std::out_of_range& e) {
95181       {
95182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95183       };
95184     } catch (std::exception& e) {
95185       {
95186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95187       };
95188     } catch (Dali::DaliException e) {
95189       {
95190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95191       };
95192     } catch (...) {
95193       {
95194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95195       };
95196     }
95197   }
95198
95199 }
95200
95201
95202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
95203   unsigned int jresult ;
95204   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95205   bool result;
95206
95207   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95208   {
95209     try {
95210       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95211     } catch (std::out_of_range& e) {
95212       {
95213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95214       };
95215     } catch (std::exception& e) {
95216       {
95217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95218       };
95219     } catch (Dali::DaliException e) {
95220       {
95221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95222       };
95223     } catch (...) {
95224       {
95225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95226       };
95227     }
95228   }
95229
95230   jresult = result;
95231   return jresult;
95232 }
95233
95234
95235 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
95236   unsigned long jresult ;
95237   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95238   std::size_t result;
95239
95240   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95241   {
95242     try {
95243       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95244     } catch (std::out_of_range& e) {
95245       {
95246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95247       };
95248     } catch (std::exception& e) {
95249       {
95250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95251       };
95252     } catch (Dali::DaliException e) {
95253       {
95254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95255       };
95256     } catch (...) {
95257       {
95258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95259       };
95260     }
95261   }
95262
95263   jresult = (unsigned long)result;
95264   return jresult;
95265 }
95266
95267
95268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
95269   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95270   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95271
95272   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95273   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95274   {
95275     try {
95276       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
95277     } catch (std::out_of_range& e) {
95278       {
95279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95280       };
95281     } catch (std::exception& e) {
95282       {
95283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95284       };
95285     } catch (Dali::DaliException e) {
95286       {
95287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95288       };
95289     } catch (...) {
95290       {
95291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95292       };
95293     }
95294   }
95295
95296 }
95297
95298
95299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
95300   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95301   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95302
95303   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95304   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95305   {
95306     try {
95307       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
95308     } catch (std::out_of_range& e) {
95309       {
95310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95311       };
95312     } catch (std::exception& e) {
95313       {
95314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95315       };
95316     } catch (Dali::DaliException e) {
95317       {
95318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95319       };
95320     } catch (...) {
95321       {
95322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95323       };
95324     }
95325   }
95326
95327 }
95328
95329
95330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
95331   unsigned int jresult ;
95332   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95333   Dali::Toolkit::Button arg2 ;
95334   Dali::Toolkit::Button *argp2 ;
95335   bool result;
95336
95337   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95338   argp2 = (Dali::Toolkit::Button *)jarg2;
95339   if (!argp2) {
95340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
95341     return 0;
95342   }
95343   arg2 = *argp2;
95344   {
95345     try {
95346       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
95347     } catch (std::out_of_range& e) {
95348       {
95349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95350       };
95351     } catch (std::exception& e) {
95352       {
95353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95354       };
95355     } catch (Dali::DaliException e) {
95356       {
95357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95358       };
95359     } catch (...) {
95360       {
95361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95362       };
95363     }
95364   }
95365
95366   jresult = result;
95367   return jresult;
95368 }
95369
95370
95371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
95372   void * jresult ;
95373   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
95374
95375   {
95376     try {
95377       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
95378     } catch (std::out_of_range& e) {
95379       {
95380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95381       };
95382     } catch (std::exception& e) {
95383       {
95384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95385       };
95386     } catch (Dali::DaliException e) {
95387       {
95388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95389       };
95390     } catch (...) {
95391       {
95392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95393       };
95394     }
95395   }
95396
95397   jresult = (void *)result;
95398   return jresult;
95399 }
95400
95401
95402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
95403   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95404
95405   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95406   {
95407     try {
95408       delete arg1;
95409     } catch (std::out_of_range& e) {
95410       {
95411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95412       };
95413     } catch (std::exception& e) {
95414       {
95415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95416       };
95417     } catch (Dali::DaliException e) {
95418       {
95419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95420       };
95421     } catch (...) {
95422       {
95423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95424       };
95425     }
95426   }
95427
95428 }
95429
95430
95431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
95432   unsigned int jresult ;
95433   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95434   bool result;
95435
95436   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95437   {
95438     try {
95439       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95440     } catch (std::out_of_range& e) {
95441       {
95442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95443       };
95444     } catch (std::exception& e) {
95445       {
95446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95447       };
95448     } catch (Dali::DaliException e) {
95449       {
95450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95451       };
95452     } catch (...) {
95453       {
95454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95455       };
95456     }
95457   }
95458
95459   jresult = result;
95460   return jresult;
95461 }
95462
95463
95464 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
95465   unsigned long jresult ;
95466   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95467   std::size_t result;
95468
95469   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95470   {
95471     try {
95472       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95473     } catch (std::out_of_range& e) {
95474       {
95475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95476       };
95477     } catch (std::exception& e) {
95478       {
95479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95480       };
95481     } catch (Dali::DaliException e) {
95482       {
95483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95484       };
95485     } catch (...) {
95486       {
95487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95488       };
95489     }
95490   }
95491
95492   jresult = (unsigned long)result;
95493   return jresult;
95494 }
95495
95496
95497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
95498   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95499   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95500
95501   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95502   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95503   {
95504     try {
95505       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
95506     } catch (std::out_of_range& e) {
95507       {
95508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95509       };
95510     } catch (std::exception& e) {
95511       {
95512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95513       };
95514     } catch (Dali::DaliException e) {
95515       {
95516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95517       };
95518     } catch (...) {
95519       {
95520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95521       };
95522     }
95523   }
95524
95525 }
95526
95527
95528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
95529   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95530   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95531
95532   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95533   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95534   {
95535     try {
95536       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
95537     } catch (std::out_of_range& e) {
95538       {
95539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95540       };
95541     } catch (std::exception& e) {
95542       {
95543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95544       };
95545     } catch (Dali::DaliException e) {
95546       {
95547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95548       };
95549     } catch (...) {
95550       {
95551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95552       };
95553     }
95554   }
95555
95556 }
95557
95558
95559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
95560   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95561   Dali::Toolkit::GaussianBlurView arg2 ;
95562   Dali::Toolkit::GaussianBlurView *argp2 ;
95563
95564   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95565   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
95566   if (!argp2) {
95567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
95568     return ;
95569   }
95570   arg2 = *argp2;
95571   {
95572     try {
95573       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
95574     } catch (std::out_of_range& e) {
95575       {
95576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95577       };
95578     } catch (std::exception& e) {
95579       {
95580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95581       };
95582     } catch (Dali::DaliException e) {
95583       {
95584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95585       };
95586     } catch (...) {
95587       {
95588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95589       };
95590     }
95591   }
95592
95593 }
95594
95595
95596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
95597   void * jresult ;
95598   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
95599
95600   {
95601     try {
95602       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
95603     } catch (std::out_of_range& e) {
95604       {
95605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95606       };
95607     } catch (std::exception& e) {
95608       {
95609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95610       };
95611     } catch (Dali::DaliException e) {
95612       {
95613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95614       };
95615     } catch (...) {
95616       {
95617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95618       };
95619     }
95620   }
95621
95622   jresult = (void *)result;
95623   return jresult;
95624 }
95625
95626
95627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
95628   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95629
95630   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95631   {
95632     try {
95633       delete arg1;
95634     } catch (std::out_of_range& e) {
95635       {
95636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95637       };
95638     } catch (std::exception& e) {
95639       {
95640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95641       };
95642     } catch (Dali::DaliException e) {
95643       {
95644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95645       };
95646     } catch (...) {
95647       {
95648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95649       };
95650     }
95651   }
95652
95653 }
95654
95655
95656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
95657   unsigned int jresult ;
95658   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95659   bool result;
95660
95661   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95662   {
95663     try {
95664       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);
95665     } catch (std::out_of_range& e) {
95666       {
95667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95668       };
95669     } catch (std::exception& e) {
95670       {
95671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95672       };
95673     } catch (Dali::DaliException e) {
95674       {
95675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95676       };
95677     } catch (...) {
95678       {
95679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95680       };
95681     }
95682   }
95683
95684   jresult = result;
95685   return jresult;
95686 }
95687
95688
95689 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
95690   unsigned long jresult ;
95691   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95692   std::size_t result;
95693
95694   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95695   {
95696     try {
95697       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);
95698     } catch (std::out_of_range& e) {
95699       {
95700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95701       };
95702     } catch (std::exception& e) {
95703       {
95704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95705       };
95706     } catch (Dali::DaliException e) {
95707       {
95708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95709       };
95710     } catch (...) {
95711       {
95712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95713       };
95714     }
95715   }
95716
95717   jresult = (unsigned long)result;
95718   return jresult;
95719 }
95720
95721
95722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
95723   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95724   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95725
95726   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95727   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95728   {
95729     try {
95730       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
95731     } catch (std::out_of_range& e) {
95732       {
95733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95734       };
95735     } catch (std::exception& e) {
95736       {
95737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95738       };
95739     } catch (Dali::DaliException e) {
95740       {
95741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95742       };
95743     } catch (...) {
95744       {
95745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95746       };
95747     }
95748   }
95749
95750 }
95751
95752
95753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
95754   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95755   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95756
95757   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95758   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95759   {
95760     try {
95761       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95762     } catch (std::out_of_range& e) {
95763       {
95764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95765       };
95766     } catch (std::exception& e) {
95767       {
95768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95769       };
95770     } catch (Dali::DaliException e) {
95771       {
95772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95773       };
95774     } catch (...) {
95775       {
95776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95777       };
95778     }
95779   }
95780
95781 }
95782
95783
95784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
95785   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95786   Dali::Toolkit::PageTurnView arg2 ;
95787   unsigned int arg3 ;
95788   bool arg4 ;
95789   Dali::Toolkit::PageTurnView *argp2 ;
95790
95791   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95792   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
95793   if (!argp2) {
95794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
95795     return ;
95796   }
95797   arg2 = *argp2;
95798   arg3 = (unsigned int)jarg3;
95799   arg4 = jarg4 ? true : false;
95800   {
95801     try {
95802       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
95803     } catch (std::out_of_range& e) {
95804       {
95805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95806       };
95807     } catch (std::exception& e) {
95808       {
95809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95810       };
95811     } catch (Dali::DaliException e) {
95812       {
95813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95814       };
95815     } catch (...) {
95816       {
95817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95818       };
95819     }
95820   }
95821
95822 }
95823
95824
95825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
95826   void * jresult ;
95827   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
95828
95829   {
95830     try {
95831       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
95832     } catch (std::out_of_range& e) {
95833       {
95834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95835       };
95836     } catch (std::exception& e) {
95837       {
95838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95839       };
95840     } catch (Dali::DaliException e) {
95841       {
95842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95843       };
95844     } catch (...) {
95845       {
95846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95847       };
95848     }
95849   }
95850
95851   jresult = (void *)result;
95852   return jresult;
95853 }
95854
95855
95856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
95857   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95858
95859   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95860   {
95861     try {
95862       delete arg1;
95863     } catch (std::out_of_range& e) {
95864       {
95865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95866       };
95867     } catch (std::exception& e) {
95868       {
95869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95870       };
95871     } catch (Dali::DaliException e) {
95872       {
95873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95874       };
95875     } catch (...) {
95876       {
95877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95878       };
95879     }
95880   }
95881
95882 }
95883
95884
95885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
95886   unsigned int jresult ;
95887   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95888   bool result;
95889
95890   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95891   {
95892     try {
95893       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
95894     } catch (std::out_of_range& e) {
95895       {
95896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95897       };
95898     } catch (std::exception& e) {
95899       {
95900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95901       };
95902     } catch (Dali::DaliException e) {
95903       {
95904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95905       };
95906     } catch (...) {
95907       {
95908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95909       };
95910     }
95911   }
95912
95913   jresult = result;
95914   return jresult;
95915 }
95916
95917
95918 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
95919   unsigned long jresult ;
95920   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95921   std::size_t result;
95922
95923   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95924   {
95925     try {
95926       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
95927     } catch (std::out_of_range& e) {
95928       {
95929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95930       };
95931     } catch (std::exception& e) {
95932       {
95933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95934       };
95935     } catch (Dali::DaliException e) {
95936       {
95937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95938       };
95939     } catch (...) {
95940       {
95941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95942       };
95943     }
95944   }
95945
95946   jresult = (unsigned long)result;
95947   return jresult;
95948 }
95949
95950
95951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
95952   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95953   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
95954
95955   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95956   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
95957   {
95958     try {
95959       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
95960     } catch (std::out_of_range& e) {
95961       {
95962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95963       };
95964     } catch (std::exception& e) {
95965       {
95966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95967       };
95968     } catch (Dali::DaliException e) {
95969       {
95970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95971       };
95972     } catch (...) {
95973       {
95974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95975       };
95976     }
95977   }
95978
95979 }
95980
95981
95982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
95983   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95984   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
95985
95986   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95987   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
95988   {
95989     try {
95990       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
95991     } catch (std::out_of_range& e) {
95992       {
95993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95994       };
95995     } catch (std::exception& e) {
95996       {
95997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95998       };
95999     } catch (Dali::DaliException e) {
96000       {
96001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96002       };
96003     } catch (...) {
96004       {
96005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96006       };
96007     }
96008   }
96009
96010 }
96011
96012
96013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
96014   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96015   Dali::Toolkit::PageTurnView arg2 ;
96016   Dali::Toolkit::PageTurnView *argp2 ;
96017
96018   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96019   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96020   if (!argp2) {
96021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96022     return ;
96023   }
96024   arg2 = *argp2;
96025   {
96026     try {
96027       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
96028     } catch (std::out_of_range& e) {
96029       {
96030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96031       };
96032     } catch (std::exception& e) {
96033       {
96034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96035       };
96036     } catch (Dali::DaliException e) {
96037       {
96038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96039       };
96040     } catch (...) {
96041       {
96042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96043       };
96044     }
96045   }
96046
96047 }
96048
96049
96050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
96051   void * jresult ;
96052   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
96053
96054   {
96055     try {
96056       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
96057     } catch (std::out_of_range& e) {
96058       {
96059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96060       };
96061     } catch (std::exception& e) {
96062       {
96063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96064       };
96065     } catch (Dali::DaliException e) {
96066       {
96067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96068       };
96069     } catch (...) {
96070       {
96071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96072       };
96073     }
96074   }
96075
96076   jresult = (void *)result;
96077   return jresult;
96078 }
96079
96080
96081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
96082   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96083
96084   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96085   {
96086     try {
96087       delete arg1;
96088     } catch (std::out_of_range& e) {
96089       {
96090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96091       };
96092     } catch (std::exception& e) {
96093       {
96094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96095       };
96096     } catch (Dali::DaliException e) {
96097       {
96098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96099       };
96100     } catch (...) {
96101       {
96102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96103       };
96104     }
96105   }
96106
96107 }
96108
96109
96110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
96111   unsigned int jresult ;
96112   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96113   bool result;
96114
96115   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96116   {
96117     try {
96118       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);
96119     } catch (std::out_of_range& e) {
96120       {
96121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96122       };
96123     } catch (std::exception& e) {
96124       {
96125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96126       };
96127     } catch (Dali::DaliException e) {
96128       {
96129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96130       };
96131     } catch (...) {
96132       {
96133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96134       };
96135     }
96136   }
96137
96138   jresult = result;
96139   return jresult;
96140 }
96141
96142
96143 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
96144   unsigned long jresult ;
96145   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96146   std::size_t result;
96147
96148   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96149   {
96150     try {
96151       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);
96152     } catch (std::out_of_range& e) {
96153       {
96154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96155       };
96156     } catch (std::exception& e) {
96157       {
96158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96159       };
96160     } catch (Dali::DaliException e) {
96161       {
96162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96163       };
96164     } catch (...) {
96165       {
96166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96167       };
96168     }
96169   }
96170
96171   jresult = (unsigned long)result;
96172   return jresult;
96173 }
96174
96175
96176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
96177   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96178   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96179
96180   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96181   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96182   {
96183     try {
96184       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
96185     } catch (std::out_of_range& e) {
96186       {
96187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96188       };
96189     } catch (std::exception& e) {
96190       {
96191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96192       };
96193     } catch (Dali::DaliException e) {
96194       {
96195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96196       };
96197     } catch (...) {
96198       {
96199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96200       };
96201     }
96202   }
96203
96204 }
96205
96206
96207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96208   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96209   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96210
96211   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96212   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96213   {
96214     try {
96215       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
96216     } catch (std::out_of_range& e) {
96217       {
96218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96219       };
96220     } catch (std::exception& e) {
96221       {
96222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96223       };
96224     } catch (Dali::DaliException e) {
96225       {
96226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96227       };
96228     } catch (...) {
96229       {
96230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96231       };
96232     }
96233   }
96234
96235 }
96236
96237
96238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
96239   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96240   Dali::Toolkit::ProgressBar arg2 ;
96241   float arg3 ;
96242   float arg4 ;
96243   Dali::Toolkit::ProgressBar *argp2 ;
96244
96245   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96246   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
96247   if (!argp2) {
96248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
96249     return ;
96250   }
96251   arg2 = *argp2;
96252   arg3 = (float)jarg3;
96253   arg4 = (float)jarg4;
96254   {
96255     try {
96256       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96257     } catch (std::out_of_range& e) {
96258       {
96259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96260       };
96261     } catch (std::exception& e) {
96262       {
96263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96264       };
96265     } catch (Dali::DaliException e) {
96266       {
96267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96268       };
96269     } catch (...) {
96270       {
96271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96272       };
96273     }
96274   }
96275
96276 }
96277
96278
96279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
96280   void * jresult ;
96281   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
96282
96283   {
96284     try {
96285       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
96286     } catch (std::out_of_range& e) {
96287       {
96288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96289       };
96290     } catch (std::exception& e) {
96291       {
96292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96293       };
96294     } catch (Dali::DaliException e) {
96295       {
96296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96297       };
96298     } catch (...) {
96299       {
96300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96301       };
96302     }
96303   }
96304
96305   jresult = (void *)result;
96306   return jresult;
96307 }
96308
96309
96310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
96311   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96312
96313   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96314   {
96315     try {
96316       delete arg1;
96317     } catch (std::out_of_range& e) {
96318       {
96319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96320       };
96321     } catch (std::exception& e) {
96322       {
96323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96324       };
96325     } catch (Dali::DaliException e) {
96326       {
96327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96328       };
96329     } catch (...) {
96330       {
96331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96332       };
96333     }
96334   }
96335
96336 }
96337
96338
96339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
96340   unsigned int jresult ;
96341   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96342   bool result;
96343
96344   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96345   {
96346     try {
96347       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);
96348     } catch (std::out_of_range& e) {
96349       {
96350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96351       };
96352     } catch (std::exception& e) {
96353       {
96354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96355       };
96356     } catch (Dali::DaliException e) {
96357       {
96358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96359       };
96360     } catch (...) {
96361       {
96362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96363       };
96364     }
96365   }
96366
96367   jresult = result;
96368   return jresult;
96369 }
96370
96371
96372 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
96373   unsigned long jresult ;
96374   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96375   std::size_t result;
96376
96377   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96378   {
96379     try {
96380       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);
96381     } catch (std::out_of_range& e) {
96382       {
96383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96384       };
96385     } catch (std::exception& e) {
96386       {
96387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96388       };
96389     } catch (Dali::DaliException e) {
96390       {
96391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96392       };
96393     } catch (...) {
96394       {
96395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96396       };
96397     }
96398   }
96399
96400   jresult = (unsigned long)result;
96401   return jresult;
96402 }
96403
96404
96405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
96406   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96407   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96408
96409   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96410   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96411   {
96412     try {
96413       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96414     } catch (std::out_of_range& e) {
96415       {
96416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96417       };
96418     } catch (std::exception& e) {
96419       {
96420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96421       };
96422     } catch (Dali::DaliException e) {
96423       {
96424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96425       };
96426     } catch (...) {
96427       {
96428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96429       };
96430     }
96431   }
96432
96433 }
96434
96435
96436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
96437   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96438   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96439
96440   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96441   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96442   {
96443     try {
96444       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96445     } catch (std::out_of_range& e) {
96446       {
96447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96448       };
96449     } catch (std::exception& e) {
96450       {
96451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96452       };
96453     } catch (Dali::DaliException e) {
96454       {
96455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96456       };
96457     } catch (...) {
96458       {
96459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96460       };
96461     }
96462   }
96463
96464 }
96465
96466
96467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
96468   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96469   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
96470
96471   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96472   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
96473   if (!arg2) {
96474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
96475     return ;
96476   }
96477   {
96478     try {
96479       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*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_new_ScrollViewSnapStartedSignal() {
96503   void * jresult ;
96504   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
96505
96506   {
96507     try {
96508       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
96509     } catch (std::out_of_range& e) {
96510       {
96511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96512       };
96513     } catch (std::exception& e) {
96514       {
96515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96516       };
96517     } catch (Dali::DaliException e) {
96518       {
96519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96520       };
96521     } catch (...) {
96522       {
96523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96524       };
96525     }
96526   }
96527
96528   jresult = (void *)result;
96529   return jresult;
96530 }
96531
96532
96533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
96534   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96535
96536   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96537   {
96538     try {
96539       delete arg1;
96540     } catch (std::out_of_range& e) {
96541       {
96542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96543       };
96544     } catch (std::exception& e) {
96545       {
96546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96547       };
96548     } catch (Dali::DaliException e) {
96549       {
96550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96551       };
96552     } catch (...) {
96553       {
96554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96555       };
96556     }
96557   }
96558
96559 }
96560
96561
96562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
96563   unsigned int jresult ;
96564   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96565   bool result;
96566
96567   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96568   {
96569     try {
96570       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96571     } catch (std::out_of_range& e) {
96572       {
96573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96574       };
96575     } catch (std::exception& e) {
96576       {
96577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96578       };
96579     } catch (Dali::DaliException e) {
96580       {
96581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96582       };
96583     } catch (...) {
96584       {
96585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96586       };
96587     }
96588   }
96589
96590   jresult = result;
96591   return jresult;
96592 }
96593
96594
96595 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
96596   unsigned long jresult ;
96597   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96598   std::size_t result;
96599
96600   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96601   {
96602     try {
96603       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96604     } catch (std::out_of_range& e) {
96605       {
96606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96607       };
96608     } catch (std::exception& e) {
96609       {
96610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96611       };
96612     } catch (Dali::DaliException e) {
96613       {
96614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96615       };
96616     } catch (...) {
96617       {
96618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96619       };
96620     }
96621   }
96622
96623   jresult = (unsigned long)result;
96624   return jresult;
96625 }
96626
96627
96628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
96629   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96630   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96631
96632   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96633   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96634   {
96635     try {
96636       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96637     } catch (std::out_of_range& e) {
96638       {
96639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96640       };
96641     } catch (std::exception& e) {
96642       {
96643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96644       };
96645     } catch (Dali::DaliException e) {
96646       {
96647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96648       };
96649     } catch (...) {
96650       {
96651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96652       };
96653     }
96654   }
96655
96656 }
96657
96658
96659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
96660   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96661   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96662
96663   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96664   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96665   {
96666     try {
96667       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96668     } catch (std::out_of_range& e) {
96669       {
96670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96671       };
96672     } catch (std::exception& e) {
96673       {
96674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96675       };
96676     } catch (Dali::DaliException e) {
96677       {
96678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96679       };
96680     } catch (...) {
96681       {
96682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96683       };
96684     }
96685   }
96686
96687 }
96688
96689
96690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
96691   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96692   Dali::Vector2 *arg2 = 0 ;
96693
96694   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96695   arg2 = (Dali::Vector2 *)jarg2;
96696   if (!arg2) {
96697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
96698     return ;
96699   }
96700   {
96701     try {
96702       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
96703     } catch (std::out_of_range& e) {
96704       {
96705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96706       };
96707     } catch (std::exception& e) {
96708       {
96709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96710       };
96711     } catch (Dali::DaliException e) {
96712       {
96713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96714       };
96715     } catch (...) {
96716       {
96717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96718       };
96719     }
96720   }
96721
96722 }
96723
96724
96725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
96726   void * jresult ;
96727   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
96728
96729   {
96730     try {
96731       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
96732     } catch (std::out_of_range& e) {
96733       {
96734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96735       };
96736     } catch (std::exception& e) {
96737       {
96738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96739       };
96740     } catch (Dali::DaliException e) {
96741       {
96742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96743       };
96744     } catch (...) {
96745       {
96746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96747       };
96748     }
96749   }
96750
96751   jresult = (void *)result;
96752   return jresult;
96753 }
96754
96755
96756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
96757   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96758
96759   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96760   {
96761     try {
96762       delete arg1;
96763     } catch (std::out_of_range& e) {
96764       {
96765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96766       };
96767     } catch (std::exception& e) {
96768       {
96769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96770       };
96771     } catch (Dali::DaliException e) {
96772       {
96773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96774       };
96775     } catch (...) {
96776       {
96777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96778       };
96779     }
96780   }
96781
96782 }
96783
96784
96785
96786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
96787   unsigned int jresult ;
96788   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96789   bool result;
96790
96791   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96792   {
96793     try {
96794       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);
96795     } catch (std::out_of_range& e) {
96796       {
96797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96798       };
96799     } catch (std::exception& e) {
96800       {
96801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96802       };
96803     } catch (Dali::DaliException e) {
96804       {
96805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96806       };
96807     } catch (...) {
96808       {
96809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96810       };
96811     }
96812   }
96813
96814   jresult = result;
96815   return jresult;
96816 }
96817
96818
96819 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
96820   unsigned long jresult ;
96821   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96822   std::size_t result;
96823
96824   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96825   {
96826     try {
96827       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);
96828     } catch (std::out_of_range& e) {
96829       {
96830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96831       };
96832     } catch (std::exception& e) {
96833       {
96834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96835       };
96836     } catch (Dali::DaliException e) {
96837       {
96838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96839       };
96840     } catch (...) {
96841       {
96842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96843       };
96844     }
96845   }
96846
96847   jresult = (unsigned long)result;
96848   return jresult;
96849 }
96850
96851
96852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
96853   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96854   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
96855
96856   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96857   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
96858   {
96859     try {
96860       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96861     } catch (std::out_of_range& e) {
96862       {
96863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96864       };
96865     } catch (std::exception& e) {
96866       {
96867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96868       };
96869     } catch (Dali::DaliException e) {
96870       {
96871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96872       };
96873     } catch (...) {
96874       {
96875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96876       };
96877     }
96878   }
96879
96880 }
96881
96882
96883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
96884   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96885   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
96886
96887   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96888   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
96889   {
96890     try {
96891       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96892     } catch (std::out_of_range& e) {
96893       {
96894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96895       };
96896     } catch (std::exception& e) {
96897       {
96898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96899       };
96900     } catch (Dali::DaliException e) {
96901       {
96902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96903       };
96904     } catch (...) {
96905       {
96906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96907       };
96908     }
96909   }
96910
96911 }
96912
96913
96914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
96915   unsigned int jresult ;
96916   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96917   Dali::Toolkit::Control arg2 ;
96918   Dali::KeyEvent *arg3 = 0 ;
96919   Dali::Toolkit::Control *argp2 ;
96920   bool result;
96921
96922   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96923   argp2 = (Dali::Toolkit::Control *)jarg2;
96924   if (!argp2) {
96925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
96926     return 0;
96927   }
96928   arg2 = *argp2;
96929   arg3 = (Dali::KeyEvent *)jarg3;
96930   if (!arg3) {
96931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
96932     return 0;
96933   }
96934   {
96935     try {
96936       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);
96937     } catch (std::out_of_range& e) {
96938       {
96939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96940       };
96941     } catch (std::exception& e) {
96942       {
96943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96944       };
96945     } catch (Dali::DaliException e) {
96946       {
96947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96948       };
96949     } catch (...) {
96950       {
96951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96952       };
96953     }
96954   }
96955
96956   jresult = result;
96957   return jresult;
96958 }
96959
96960
96961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
96962   void * jresult ;
96963   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
96964
96965   {
96966     try {
96967       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
96968     } catch (std::out_of_range& e) {
96969       {
96970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96971       };
96972     } catch (std::exception& e) {
96973       {
96974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96975       };
96976     } catch (Dali::DaliException e) {
96977       {
96978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96979       };
96980     } catch (...) {
96981       {
96982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96983       };
96984     }
96985   }
96986
96987   jresult = (void *)result;
96988   return jresult;
96989 }
96990
96991
96992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
96993   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96994
96995   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96996   {
96997     try {
96998       delete arg1;
96999     } catch (std::out_of_range& e) {
97000       {
97001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97002       };
97003     } catch (std::exception& e) {
97004       {
97005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97006       };
97007     } catch (Dali::DaliException e) {
97008       {
97009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97010       };
97011     } catch (...) {
97012       {
97013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97014       };
97015     }
97016   }
97017
97018 }
97019
97020
97021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
97022   unsigned int jresult ;
97023   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97024   bool result;
97025
97026   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97027   {
97028     try {
97029       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97030     } catch (std::out_of_range& e) {
97031       {
97032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97033       };
97034     } catch (std::exception& e) {
97035       {
97036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97037       };
97038     } catch (Dali::DaliException e) {
97039       {
97040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97041       };
97042     } catch (...) {
97043       {
97044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97045       };
97046     }
97047   }
97048
97049   jresult = result;
97050   return jresult;
97051 }
97052
97053
97054 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
97055   unsigned long jresult ;
97056   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97057   std::size_t result;
97058
97059   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97060   {
97061     try {
97062       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97063     } catch (std::out_of_range& e) {
97064       {
97065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97066       };
97067     } catch (std::exception& e) {
97068       {
97069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97070       };
97071     } catch (Dali::DaliException e) {
97072       {
97073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97074       };
97075     } catch (...) {
97076       {
97077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97078       };
97079     }
97080   }
97081
97082   jresult = (unsigned long)result;
97083   return jresult;
97084 }
97085
97086
97087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
97088   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97089   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97090
97091   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97092   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97093   {
97094     try {
97095       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
97096     } catch (std::out_of_range& e) {
97097       {
97098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97099       };
97100     } catch (std::exception& e) {
97101       {
97102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97103       };
97104     } catch (Dali::DaliException e) {
97105       {
97106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97107       };
97108     } catch (...) {
97109       {
97110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97111       };
97112     }
97113   }
97114
97115 }
97116
97117
97118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
97119   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97120   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97121
97122   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97123   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97124   {
97125     try {
97126       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
97127     } catch (std::out_of_range& e) {
97128       {
97129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97130       };
97131     } catch (std::exception& e) {
97132       {
97133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97134       };
97135     } catch (Dali::DaliException e) {
97136       {
97137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97138       };
97139     } catch (...) {
97140       {
97141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97142       };
97143     }
97144   }
97145
97146 }
97147
97148
97149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
97150   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97151   Dali::Toolkit::Control arg2 ;
97152   Dali::Toolkit::Control *argp2 ;
97153
97154   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97155   argp2 = (Dali::Toolkit::Control *)jarg2;
97156   if (!argp2) {
97157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97158     return ;
97159   }
97160   arg2 = *argp2;
97161   {
97162     try {
97163       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
97164     } catch (std::out_of_range& e) {
97165       {
97166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97167       };
97168     } catch (std::exception& e) {
97169       {
97170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97171       };
97172     } catch (Dali::DaliException e) {
97173       {
97174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97175       };
97176     } catch (...) {
97177       {
97178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97179       };
97180     }
97181   }
97182
97183 }
97184
97185
97186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
97187   void * jresult ;
97188   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
97189
97190   {
97191     try {
97192       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
97193     } catch (std::out_of_range& e) {
97194       {
97195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97196       };
97197     } catch (std::exception& e) {
97198       {
97199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97200       };
97201     } catch (Dali::DaliException e) {
97202       {
97203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97204       };
97205     } catch (...) {
97206       {
97207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97208       };
97209     }
97210   }
97211
97212   jresult = (void *)result;
97213   return jresult;
97214 }
97215
97216
97217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
97218   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97219
97220   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97221   {
97222     try {
97223       delete arg1;
97224     } catch (std::out_of_range& e) {
97225       {
97226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97227       };
97228     } catch (std::exception& e) {
97229       {
97230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97231       };
97232     } catch (Dali::DaliException e) {
97233       {
97234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97235       };
97236     } catch (...) {
97237       {
97238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97239       };
97240     }
97241   }
97242
97243 }
97244
97245
97246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
97247   unsigned int jresult ;
97248   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97249   bool result;
97250
97251   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97252   {
97253     try {
97254       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97255     } catch (std::out_of_range& e) {
97256       {
97257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97258       };
97259     } catch (std::exception& e) {
97260       {
97261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97262       };
97263     } catch (Dali::DaliException e) {
97264       {
97265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97266       };
97267     } catch (...) {
97268       {
97269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97270       };
97271     }
97272   }
97273
97274   jresult = result;
97275   return jresult;
97276 }
97277
97278
97279 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
97280   unsigned long jresult ;
97281   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97282   std::size_t result;
97283
97284   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97285   {
97286     try {
97287       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97288     } catch (std::out_of_range& e) {
97289       {
97290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97291       };
97292     } catch (std::exception& e) {
97293       {
97294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97295       };
97296     } catch (Dali::DaliException e) {
97297       {
97298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97299       };
97300     } catch (...) {
97301       {
97302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97303       };
97304     }
97305   }
97306
97307   jresult = (unsigned long)result;
97308   return jresult;
97309 }
97310
97311
97312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
97313   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97314   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97315
97316   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97317   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97318   {
97319     try {
97320       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
97321     } catch (std::out_of_range& e) {
97322       {
97323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97324       };
97325     } catch (std::exception& e) {
97326       {
97327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97328       };
97329     } catch (Dali::DaliException e) {
97330       {
97331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97332       };
97333     } catch (...) {
97334       {
97335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97336       };
97337     }
97338   }
97339
97340 }
97341
97342
97343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
97344   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97345   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97346
97347   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97348   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97349   {
97350     try {
97351       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
97352     } catch (std::out_of_range& e) {
97353       {
97354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97355       };
97356     } catch (std::exception& e) {
97357       {
97358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97359       };
97360     } catch (Dali::DaliException e) {
97361       {
97362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97363       };
97364     } catch (...) {
97365       {
97366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97367       };
97368     }
97369   }
97370
97371 }
97372
97373
97374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
97375   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97376   Dali::Toolkit::VideoView *arg2 = 0 ;
97377
97378   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97379   arg2 = (Dali::Toolkit::VideoView *)jarg2;
97380   if (!arg2) {
97381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
97382     return ;
97383   }
97384   {
97385     try {
97386       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
97387     } catch (std::out_of_range& e) {
97388       {
97389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97390       };
97391     } catch (std::exception& e) {
97392       {
97393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97394       };
97395     } catch (Dali::DaliException e) {
97396       {
97397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97398       };
97399     } catch (...) {
97400       {
97401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97402       };
97403     }
97404   }
97405
97406 }
97407
97408
97409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
97410   void * jresult ;
97411   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
97412
97413   {
97414     try {
97415       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
97416     } catch (std::out_of_range& e) {
97417       {
97418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97419       };
97420     } catch (std::exception& e) {
97421       {
97422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97423       };
97424     } catch (Dali::DaliException e) {
97425       {
97426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97427       };
97428     } catch (...) {
97429       {
97430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97431       };
97432     }
97433   }
97434
97435   jresult = (void *)result;
97436   return jresult;
97437 }
97438
97439
97440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
97441   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97442
97443   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97444   {
97445     try {
97446       delete arg1;
97447     } catch (std::out_of_range& e) {
97448       {
97449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97450       };
97451     } catch (std::exception& e) {
97452       {
97453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97454       };
97455     } catch (Dali::DaliException e) {
97456       {
97457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97458       };
97459     } catch (...) {
97460       {
97461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97462       };
97463     }
97464   }
97465
97466 }
97467
97468
97469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
97470   unsigned int jresult ;
97471   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97472   bool result;
97473
97474   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97475   {
97476     try {
97477       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97478     } catch (std::out_of_range& e) {
97479       {
97480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97481       };
97482     } catch (std::exception& e) {
97483       {
97484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97485       };
97486     } catch (Dali::DaliException e) {
97487       {
97488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97489       };
97490     } catch (...) {
97491       {
97492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97493       };
97494     }
97495   }
97496
97497   jresult = result;
97498   return jresult;
97499 }
97500
97501
97502 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
97503   unsigned long jresult ;
97504   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97505   std::size_t result;
97506
97507   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97508   {
97509     try {
97510       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97511     } catch (std::out_of_range& e) {
97512       {
97513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97514       };
97515     } catch (std::exception& e) {
97516       {
97517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97518       };
97519     } catch (Dali::DaliException e) {
97520       {
97521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97522       };
97523     } catch (...) {
97524       {
97525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97526       };
97527     }
97528   }
97529
97530   jresult = (unsigned long)result;
97531   return jresult;
97532 }
97533
97534
97535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97536   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97537   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97538
97539   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97540   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97541   {
97542     try {
97543       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
97544     } catch (std::out_of_range& e) {
97545       {
97546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97547       };
97548     } catch (std::exception& e) {
97549       {
97550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97551       };
97552     } catch (Dali::DaliException e) {
97553       {
97554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97555       };
97556     } catch (...) {
97557       {
97558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97559       };
97560     }
97561   }
97562
97563 }
97564
97565
97566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97567   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97568   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97569
97570   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97571   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97572   {
97573     try {
97574       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97575     } catch (std::out_of_range& e) {
97576       {
97577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97578       };
97579     } catch (std::exception& e) {
97580       {
97581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97582       };
97583     } catch (Dali::DaliException e) {
97584       {
97585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97586       };
97587     } catch (...) {
97588       {
97589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97590       };
97591     }
97592   }
97593
97594 }
97595
97596
97597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
97598   unsigned int jresult ;
97599   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97600   Dali::Toolkit::Slider arg2 ;
97601   float arg3 ;
97602   Dali::Toolkit::Slider *argp2 ;
97603   bool result;
97604
97605   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97606   argp2 = (Dali::Toolkit::Slider *)jarg2;
97607   if (!argp2) {
97608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
97609     return 0;
97610   }
97611   arg2 = *argp2;
97612   arg3 = (float)jarg3;
97613   {
97614     try {
97615       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
97616     } catch (std::out_of_range& e) {
97617       {
97618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97619       };
97620     } catch (std::exception& e) {
97621       {
97622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97623       };
97624     } catch (Dali::DaliException e) {
97625       {
97626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97627       };
97628     } catch (...) {
97629       {
97630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97631       };
97632     }
97633   }
97634
97635   jresult = result;
97636   return jresult;
97637 }
97638
97639
97640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
97641   void * jresult ;
97642   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
97643
97644   {
97645     try {
97646       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
97647     } catch (std::out_of_range& e) {
97648       {
97649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97650       };
97651     } catch (std::exception& e) {
97652       {
97653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97654       };
97655     } catch (Dali::DaliException e) {
97656       {
97657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97658       };
97659     } catch (...) {
97660       {
97661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97662       };
97663     }
97664   }
97665
97666   jresult = (void *)result;
97667   return jresult;
97668 }
97669
97670
97671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
97672   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97673
97674   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97675   {
97676     try {
97677       delete arg1;
97678     } catch (std::out_of_range& e) {
97679       {
97680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97681       };
97682     } catch (std::exception& e) {
97683       {
97684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97685       };
97686     } catch (Dali::DaliException e) {
97687       {
97688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97689       };
97690     } catch (...) {
97691       {
97692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97693       };
97694     }
97695   }
97696
97697 }
97698
97699
97700 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
97701   unsigned int jresult ;
97702   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97703   bool result;
97704
97705   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97706   {
97707     try {
97708       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97709     } catch (std::out_of_range& e) {
97710       {
97711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97712       };
97713     } catch (std::exception& e) {
97714       {
97715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97716       };
97717     } catch (Dali::DaliException e) {
97718       {
97719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97720       };
97721     } catch (...) {
97722       {
97723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97724       };
97725     }
97726   }
97727
97728   jresult = result;
97729   return jresult;
97730 }
97731
97732
97733 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
97734   unsigned long jresult ;
97735   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97736   std::size_t result;
97737
97738   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97739   {
97740     try {
97741       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97742     } catch (std::out_of_range& e) {
97743       {
97744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97745       };
97746     } catch (std::exception& e) {
97747       {
97748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97749       };
97750     } catch (Dali::DaliException e) {
97751       {
97752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97753       };
97754     } catch (...) {
97755       {
97756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97757       };
97758     }
97759   }
97760
97761   jresult = (unsigned long)result;
97762   return jresult;
97763 }
97764
97765
97766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
97767   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97768   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97769
97770   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97771   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97772   {
97773     try {
97774       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
97775     } catch (std::out_of_range& e) {
97776       {
97777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97778       };
97779     } catch (std::exception& e) {
97780       {
97781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97782       };
97783     } catch (Dali::DaliException e) {
97784       {
97785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97786       };
97787     } catch (...) {
97788       {
97789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97790       };
97791     }
97792   }
97793
97794 }
97795
97796
97797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
97798   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97799   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97800
97801   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97802   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97803   {
97804     try {
97805       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
97806     } catch (std::out_of_range& e) {
97807       {
97808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97809       };
97810     } catch (std::exception& e) {
97811       {
97812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97813       };
97814     } catch (Dali::DaliException e) {
97815       {
97816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97817       };
97818     } catch (...) {
97819       {
97820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97821       };
97822     }
97823   }
97824
97825 }
97826
97827
97828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
97829   unsigned int jresult ;
97830   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97831   Dali::Toolkit::Slider arg2 ;
97832   int arg3 ;
97833   Dali::Toolkit::Slider *argp2 ;
97834   bool result;
97835
97836   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97837   argp2 = (Dali::Toolkit::Slider *)jarg2;
97838   if (!argp2) {
97839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
97840     return 0;
97841   }
97842   arg2 = *argp2;
97843   arg3 = (int)jarg3;
97844   {
97845     try {
97846       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
97847     } catch (std::out_of_range& e) {
97848       {
97849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97850       };
97851     } catch (std::exception& e) {
97852       {
97853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97854       };
97855     } catch (Dali::DaliException e) {
97856       {
97857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97858       };
97859     } catch (...) {
97860       {
97861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97862       };
97863     }
97864   }
97865
97866   jresult = result;
97867   return jresult;
97868 }
97869
97870
97871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
97872   void * jresult ;
97873   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
97874
97875   {
97876     try {
97877       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
97878     } catch (std::out_of_range& e) {
97879       {
97880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97881       };
97882     } catch (std::exception& e) {
97883       {
97884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97885       };
97886     } catch (Dali::DaliException e) {
97887       {
97888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97889       };
97890     } catch (...) {
97891       {
97892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97893       };
97894     }
97895   }
97896
97897   jresult = (void *)result;
97898   return jresult;
97899 }
97900
97901
97902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
97903   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97904
97905   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97906   {
97907     try {
97908       delete arg1;
97909     } catch (std::out_of_range& e) {
97910       {
97911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97912       };
97913     } catch (std::exception& e) {
97914       {
97915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97916       };
97917     } catch (Dali::DaliException e) {
97918       {
97919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97920       };
97921     } catch (...) {
97922       {
97923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97924       };
97925     }
97926   }
97927
97928 }
97929
97930
97931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
97932   void * jresult ;
97933   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
97934
97935   {
97936     try {
97937       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
97938     } catch (std::out_of_range& e) {
97939       {
97940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97941       };
97942     } catch (std::exception& e) {
97943       {
97944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97945       };
97946     } catch (Dali::DaliException e) {
97947       {
97948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97949       };
97950     } catch (...) {
97951       {
97952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97953       };
97954     }
97955   }
97956
97957   jresult = (void *)result;
97958   return jresult;
97959 }
97960
97961
97962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
97963   void * jresult ;
97964   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
97965   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
97966
97967   arg1 = (Dali::Toolkit::Ruler *)jarg1;
97968   {
97969     try {
97970       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
97971     } catch (std::out_of_range& e) {
97972       {
97973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97974       };
97975     } catch (std::exception& e) {
97976       {
97977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97978       };
97979     } catch (Dali::DaliException e) {
97980       {
97981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97982       };
97983     } catch (...) {
97984       {
97985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97986       };
97987     }
97988   }
97989
97990   jresult = (void *)result;
97991   return jresult;
97992 }
97993
97994
97995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
97996   void * jresult ;
97997   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
97998   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
97999
98000   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98001   if (!arg1) {
98002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98003     return 0;
98004   }
98005   {
98006     try {
98007       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
98008     } catch (std::out_of_range& e) {
98009       {
98010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98011       };
98012     } catch (std::exception& e) {
98013       {
98014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98015       };
98016     } catch (Dali::DaliException e) {
98017       {
98018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98019       };
98020     } catch (...) {
98021       {
98022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98023       };
98024     }
98025   }
98026
98027   jresult = (void *)result;
98028   return jresult;
98029 }
98030
98031
98032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
98033   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98034
98035   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98036   {
98037     try {
98038       delete arg1;
98039     } catch (std::out_of_range& e) {
98040       {
98041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98042       };
98043     } catch (std::exception& e) {
98044       {
98045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98046       };
98047     } catch (Dali::DaliException e) {
98048       {
98049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98050       };
98051     } catch (...) {
98052       {
98053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98054       };
98055     }
98056   }
98057
98058 }
98059
98060
98061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
98062   void * jresult ;
98063   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98064   Dali::Toolkit::Ruler *result = 0 ;
98065
98066   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98067   {
98068     try {
98069       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
98070     } catch (std::out_of_range& e) {
98071       {
98072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98073       };
98074     } catch (std::exception& e) {
98075       {
98076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98077       };
98078     } catch (Dali::DaliException e) {
98079       {
98080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98081       };
98082     } catch (...) {
98083       {
98084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98085       };
98086     }
98087   }
98088
98089   jresult = (void *)result;
98090   return jresult;
98091 }
98092
98093
98094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
98095   void * jresult ;
98096   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98097   Dali::Toolkit::Ruler *result = 0 ;
98098
98099   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98100   {
98101     try {
98102       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
98103     } catch (std::out_of_range& e) {
98104       {
98105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98106       };
98107     } catch (std::exception& e) {
98108       {
98109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98110       };
98111     } catch (Dali::DaliException e) {
98112       {
98113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98114       };
98115     } catch (...) {
98116       {
98117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98118       };
98119     }
98120   }
98121
98122   jresult = (void *)result;
98123   return jresult;
98124 }
98125
98126
98127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
98128   void * jresult ;
98129   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98130   Dali::Toolkit::Ruler *result = 0 ;
98131
98132   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98133   {
98134     try {
98135       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
98136     } catch (std::out_of_range& e) {
98137       {
98138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98139       };
98140     } catch (std::exception& e) {
98141       {
98142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98143       };
98144     } catch (Dali::DaliException e) {
98145       {
98146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98147       };
98148     } catch (...) {
98149       {
98150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98151       };
98152     }
98153   }
98154
98155   jresult = (void *)result;
98156   return jresult;
98157 }
98158
98159
98160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
98161   void * jresult ;
98162   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98163   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
98164   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98165
98166   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98167   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
98168   if (!arg2) {
98169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98170     return 0;
98171   }
98172   {
98173     try {
98174       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
98175     } catch (std::out_of_range& e) {
98176       {
98177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98178       };
98179     } catch (std::exception& e) {
98180       {
98181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98182       };
98183     } catch (Dali::DaliException e) {
98184       {
98185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98186       };
98187     } catch (...) {
98188       {
98189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98190       };
98191     }
98192   }
98193
98194   jresult = (void *)result;
98195   return jresult;
98196 }
98197
98198
98199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
98200   void * jresult ;
98201   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98202   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98203   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98204
98205   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98206   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98207   {
98208     try {
98209       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
98210     } catch (std::out_of_range& e) {
98211       {
98212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98213       };
98214     } catch (std::exception& e) {
98215       {
98216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98217       };
98218     } catch (Dali::DaliException e) {
98219       {
98220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98221       };
98222     } catch (...) {
98223       {
98224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98225       };
98226     }
98227   }
98228
98229   jresult = (void *)result;
98230   return jresult;
98231 }
98232
98233
98234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
98235   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98236
98237   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98238   {
98239     try {
98240       (arg1)->Reset();
98241     } catch (std::out_of_range& e) {
98242       {
98243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98244       };
98245     } catch (std::exception& e) {
98246       {
98247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98248       };
98249     } catch (Dali::DaliException e) {
98250       {
98251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98252       };
98253     } catch (...) {
98254       {
98255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98256       };
98257     }
98258   }
98259
98260 }
98261
98262
98263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
98264   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98265   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98266
98267   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98268   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98269   {
98270     try {
98271       (arg1)->Reset(arg2);
98272     } catch (std::out_of_range& e) {
98273       {
98274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98275       };
98276     } catch (std::exception& e) {
98277       {
98278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98279       };
98280     } catch (Dali::DaliException e) {
98281       {
98282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98283       };
98284     } catch (...) {
98285       {
98286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98287       };
98288     }
98289   }
98290
98291 }
98292
98293
98294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
98295   void * jresult ;
98296   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98297   Dali::Toolkit::Ruler *result = 0 ;
98298
98299   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98300   {
98301     try {
98302       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
98303     } catch (std::out_of_range& e) {
98304       {
98305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98306       };
98307     } catch (std::exception& e) {
98308       {
98309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98310       };
98311     } catch (Dali::DaliException e) {
98312       {
98313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98314       };
98315     } catch (...) {
98316       {
98317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98318       };
98319     }
98320   }
98321
98322   jresult = (void *)result;
98323   return jresult;
98324 }
98325
98326
98327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
98328   float jresult ;
98329   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98330   float arg2 ;
98331   float arg3 ;
98332   float result;
98333
98334   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98335   arg2 = (float)jarg2;
98336   arg3 = (float)jarg3;
98337   {
98338     try {
98339       result = (float)(*arg1)->Snap(arg2,arg3);
98340     } catch (std::out_of_range& e) {
98341       {
98342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98343       };
98344     } catch (std::exception& e) {
98345       {
98346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98347       };
98348     } catch (Dali::DaliException e) {
98349       {
98350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98351       };
98352     } catch (...) {
98353       {
98354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98355       };
98356     }
98357   }
98358
98359   jresult = result;
98360   return jresult;
98361 }
98362
98363
98364 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
98365   float jresult ;
98366   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98367   float arg2 ;
98368   float result;
98369
98370   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98371   arg2 = (float)jarg2;
98372   {
98373     try {
98374       result = (float)(*arg1)->Snap(arg2);
98375     } catch (std::out_of_range& e) {
98376       {
98377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98378       };
98379     } catch (std::exception& e) {
98380       {
98381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98382       };
98383     } catch (Dali::DaliException e) {
98384       {
98385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98386       };
98387     } catch (...) {
98388       {
98389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98390       };
98391     }
98392   }
98393
98394   jresult = result;
98395   return jresult;
98396 }
98397
98398
98399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
98400   float jresult ;
98401   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98402   unsigned int arg2 ;
98403   unsigned int *arg3 = 0 ;
98404   bool arg4 ;
98405   float result;
98406
98407   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98408   arg2 = (unsigned int)jarg2;
98409   arg3 = (unsigned int *)jarg3;
98410   arg4 = jarg4 ? true : false;
98411   {
98412     try {
98413       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
98414     } catch (std::out_of_range& e) {
98415       {
98416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98417       };
98418     } catch (std::exception& e) {
98419       {
98420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98421       };
98422     } catch (Dali::DaliException e) {
98423       {
98424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98425       };
98426     } catch (...) {
98427       {
98428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98429       };
98430     }
98431   }
98432
98433   jresult = result;
98434   return jresult;
98435 }
98436
98437
98438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
98439   unsigned int jresult ;
98440   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98441   float arg2 ;
98442   bool arg3 ;
98443   unsigned int result;
98444
98445   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98446   arg2 = (float)jarg2;
98447   arg3 = jarg3 ? true : false;
98448   {
98449     try {
98450       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
98451     } catch (std::out_of_range& e) {
98452       {
98453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98454       };
98455     } catch (std::exception& e) {
98456       {
98457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98458       };
98459     } catch (Dali::DaliException e) {
98460       {
98461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98462       };
98463     } catch (...) {
98464       {
98465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98466       };
98467     }
98468   }
98469
98470   jresult = result;
98471   return jresult;
98472 }
98473
98474
98475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
98476   unsigned int jresult ;
98477   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98478   unsigned int result;
98479
98480   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98481   {
98482     try {
98483       result = (unsigned int)(*arg1)->GetTotalPages();
98484     } catch (std::out_of_range& e) {
98485       {
98486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98487       };
98488     } catch (std::exception& e) {
98489       {
98490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98491       };
98492     } catch (Dali::DaliException e) {
98493       {
98494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98495       };
98496     } catch (...) {
98497       {
98498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98499       };
98500     }
98501   }
98502
98503   jresult = result;
98504   return jresult;
98505 }
98506
98507
98508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
98509   int jresult ;
98510   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98511   Dali::Toolkit::Ruler::RulerType result;
98512
98513   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98514   {
98515     try {
98516       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
98517     } catch (std::out_of_range& e) {
98518       {
98519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98520       };
98521     } catch (std::exception& e) {
98522       {
98523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98524       };
98525     } catch (Dali::DaliException e) {
98526       {
98527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98528       };
98529     } catch (...) {
98530       {
98531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98532       };
98533     }
98534   }
98535
98536   jresult = (int)result;
98537   return jresult;
98538 }
98539
98540
98541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
98542   unsigned int jresult ;
98543   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98544   bool result;
98545
98546   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98547   {
98548     try {
98549       result = (bool)(*arg1)->IsEnabled();
98550     } catch (std::out_of_range& e) {
98551       {
98552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98553       };
98554     } catch (std::exception& e) {
98555       {
98556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98557       };
98558     } catch (Dali::DaliException e) {
98559       {
98560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98561       };
98562     } catch (...) {
98563       {
98564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98565       };
98566     }
98567   }
98568
98569   jresult = result;
98570   return jresult;
98571 }
98572
98573
98574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
98575   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98576
98577   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98578   {
98579     try {
98580       (*arg1)->Enable();
98581     } catch (std::out_of_range& e) {
98582       {
98583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98584       };
98585     } catch (std::exception& e) {
98586       {
98587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98588       };
98589     } catch (Dali::DaliException e) {
98590       {
98591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98592       };
98593     } catch (...) {
98594       {
98595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98596       };
98597     }
98598   }
98599
98600 }
98601
98602
98603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
98604   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98605
98606   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98607   {
98608     try {
98609       (*arg1)->Disable();
98610     } catch (std::out_of_range& e) {
98611       {
98612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98613       };
98614     } catch (std::exception& e) {
98615       {
98616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98617       };
98618     } catch (Dali::DaliException e) {
98619       {
98620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98621       };
98622     } catch (...) {
98623       {
98624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98625       };
98626     }
98627   }
98628
98629 }
98630
98631
98632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
98633   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98634   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
98635   Dali::Toolkit::RulerDomain *argp2 ;
98636
98637   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98638   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
98639   if (!argp2) {
98640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
98641     return ;
98642   }
98643   arg2 = *argp2;
98644   {
98645     try {
98646       (*arg1)->SetDomain(arg2);
98647     } catch (std::out_of_range& e) {
98648       {
98649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98650       };
98651     } catch (std::exception& e) {
98652       {
98653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98654       };
98655     } catch (Dali::DaliException e) {
98656       {
98657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98658       };
98659     } catch (...) {
98660       {
98661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98662       };
98663     }
98664   }
98665
98666 }
98667
98668
98669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
98670   void * jresult ;
98671   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98672   Dali::Toolkit::RulerDomain *result = 0 ;
98673
98674   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98675   {
98676     try {
98677       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
98678     } catch (std::out_of_range& e) {
98679       {
98680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98681       };
98682     } catch (std::exception& e) {
98683       {
98684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98685       };
98686     } catch (Dali::DaliException e) {
98687       {
98688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98689       };
98690     } catch (...) {
98691       {
98692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98693       };
98694     }
98695   }
98696
98697   jresult = (void *)result;
98698   return jresult;
98699 }
98700
98701
98702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
98703   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98704
98705   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98706   {
98707     try {
98708       (*arg1)->DisableDomain();
98709     } catch (std::out_of_range& e) {
98710       {
98711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98712       };
98713     } catch (std::exception& e) {
98714       {
98715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98716       };
98717     } catch (Dali::DaliException e) {
98718       {
98719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98720       };
98721     } catch (...) {
98722       {
98723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98724       };
98725     }
98726   }
98727
98728 }
98729
98730
98731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
98732   float jresult ;
98733   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98734   float arg2 ;
98735   float arg3 ;
98736   float arg4 ;
98737   float result;
98738
98739   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98740   arg2 = (float)jarg2;
98741   arg3 = (float)jarg3;
98742   arg4 = (float)jarg4;
98743   {
98744     try {
98745       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
98746     } catch (std::out_of_range& e) {
98747       {
98748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98749       };
98750     } catch (std::exception& e) {
98751       {
98752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98753       };
98754     } catch (Dali::DaliException e) {
98755       {
98756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98757       };
98758     } catch (...) {
98759       {
98760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98761       };
98762     }
98763   }
98764
98765   jresult = result;
98766   return jresult;
98767 }
98768
98769
98770 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
98771   float jresult ;
98772   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98773   float arg2 ;
98774   float arg3 ;
98775   float result;
98776
98777   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98778   arg2 = (float)jarg2;
98779   arg3 = (float)jarg3;
98780   {
98781     try {
98782       result = (float)(*arg1)->Clamp(arg2,arg3);
98783     } catch (std::out_of_range& e) {
98784       {
98785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98786       };
98787     } catch (std::exception& e) {
98788       {
98789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98790       };
98791     } catch (Dali::DaliException e) {
98792       {
98793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98794       };
98795     } catch (...) {
98796       {
98797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98798       };
98799     }
98800   }
98801
98802   jresult = result;
98803   return jresult;
98804 }
98805
98806
98807 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
98808   float jresult ;
98809   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98810   float arg2 ;
98811   float result;
98812
98813   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98814   arg2 = (float)jarg2;
98815   {
98816     try {
98817       result = (float)(*arg1)->Clamp(arg2);
98818     } catch (std::out_of_range& e) {
98819       {
98820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98821       };
98822     } catch (std::exception& e) {
98823       {
98824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98825       };
98826     } catch (Dali::DaliException e) {
98827       {
98828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98829       };
98830     } catch (...) {
98831       {
98832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98833       };
98834     }
98835   }
98836
98837   jresult = result;
98838   return jresult;
98839 }
98840
98841
98842 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
98843   float jresult ;
98844   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98845   float arg2 ;
98846   float arg3 ;
98847   float arg4 ;
98848   Dali::Toolkit::ClampState *arg5 = 0 ;
98849   float result;
98850
98851   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98852   arg2 = (float)jarg2;
98853   arg3 = (float)jarg3;
98854   arg4 = (float)jarg4;
98855   arg5 = (Dali::Toolkit::ClampState *)jarg5;
98856   if (!arg5) {
98857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
98858     return 0;
98859   }
98860   {
98861     try {
98862       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
98863     } catch (std::out_of_range& e) {
98864       {
98865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98866       };
98867     } catch (std::exception& e) {
98868       {
98869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98870       };
98871     } catch (Dali::DaliException e) {
98872       {
98873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98874       };
98875     } catch (...) {
98876       {
98877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98878       };
98879     }
98880   }
98881
98882   jresult = result;
98883   return jresult;
98884 }
98885
98886
98887 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
98888   float jresult ;
98889   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98890   float arg2 ;
98891   float arg3 ;
98892   float arg4 ;
98893   float arg5 ;
98894   float result;
98895
98896   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98897   arg2 = (float)jarg2;
98898   arg3 = (float)jarg3;
98899   arg4 = (float)jarg4;
98900   arg5 = (float)jarg5;
98901   {
98902     try {
98903       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
98904     } catch (std::out_of_range& e) {
98905       {
98906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98907       };
98908     } catch (std::exception& e) {
98909       {
98910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98911       };
98912     } catch (Dali::DaliException e) {
98913       {
98914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98915       };
98916     } catch (...) {
98917       {
98918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98919       };
98920     }
98921   }
98922
98923   jresult = result;
98924   return jresult;
98925 }
98926
98927
98928 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
98929   float jresult ;
98930   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98931   float arg2 ;
98932   float arg3 ;
98933   float arg4 ;
98934   float result;
98935
98936   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98937   arg2 = (float)jarg2;
98938   arg3 = (float)jarg3;
98939   arg4 = (float)jarg4;
98940   {
98941     try {
98942       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
98943     } catch (std::out_of_range& e) {
98944       {
98945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98946       };
98947     } catch (std::exception& e) {
98948       {
98949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98950       };
98951     } catch (Dali::DaliException e) {
98952       {
98953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98954       };
98955     } catch (...) {
98956       {
98957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98958       };
98959     }
98960   }
98961
98962   jresult = result;
98963   return jresult;
98964 }
98965
98966
98967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
98968   float jresult ;
98969   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98970   float arg2 ;
98971   float arg3 ;
98972   float result;
98973
98974   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98975   arg2 = (float)jarg2;
98976   arg3 = (float)jarg3;
98977   {
98978     try {
98979       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
98980     } catch (std::out_of_range& e) {
98981       {
98982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98983       };
98984     } catch (std::exception& e) {
98985       {
98986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98987       };
98988     } catch (Dali::DaliException e) {
98989       {
98990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98991       };
98992     } catch (...) {
98993       {
98994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98995       };
98996     }
98997   }
98998
98999   jresult = result;
99000   return jresult;
99001 }
99002
99003
99004 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
99005   float jresult ;
99006   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99007   float arg2 ;
99008   float result;
99009
99010   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99011   arg2 = (float)jarg2;
99012   {
99013     try {
99014       result = (float)(*arg1)->SnapAndClamp(arg2);
99015     } catch (std::out_of_range& e) {
99016       {
99017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99018       };
99019     } catch (std::exception& e) {
99020       {
99021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99022       };
99023     } catch (Dali::DaliException e) {
99024       {
99025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99026       };
99027     } catch (...) {
99028       {
99029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99030       };
99031     }
99032   }
99033
99034   jresult = result;
99035   return jresult;
99036 }
99037
99038
99039 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
99040   float jresult ;
99041   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99042   float arg2 ;
99043   float arg3 ;
99044   float arg4 ;
99045   float arg5 ;
99046   Dali::Toolkit::ClampState *arg6 = 0 ;
99047   float result;
99048
99049   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99050   arg2 = (float)jarg2;
99051   arg3 = (float)jarg3;
99052   arg4 = (float)jarg4;
99053   arg5 = (float)jarg5;
99054   arg6 = (Dali::Toolkit::ClampState *)jarg6;
99055   if (!arg6) {
99056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99057     return 0;
99058   }
99059   {
99060     try {
99061       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
99062     } catch (std::out_of_range& e) {
99063       {
99064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99065       };
99066     } catch (std::exception& e) {
99067       {
99068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99069       };
99070     } catch (Dali::DaliException e) {
99071       {
99072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99073       };
99074     } catch (...) {
99075       {
99076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99077       };
99078     }
99079   }
99080
99081   jresult = result;
99082   return jresult;
99083 }
99084
99085
99086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
99087   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99088
99089   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99090   {
99091     try {
99092       (*arg1)->Reference();
99093     } catch (std::out_of_range& e) {
99094       {
99095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99096       };
99097     } catch (std::exception& e) {
99098       {
99099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99100       };
99101     } catch (Dali::DaliException e) {
99102       {
99103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99104       };
99105     } catch (...) {
99106       {
99107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99108       };
99109     }
99110   }
99111
99112 }
99113
99114
99115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
99116   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99117
99118   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99119   {
99120     try {
99121       (*arg1)->Unreference();
99122     } catch (std::out_of_range& e) {
99123       {
99124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99125       };
99126     } catch (std::exception& e) {
99127       {
99128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99129       };
99130     } catch (Dali::DaliException e) {
99131       {
99132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99133       };
99134     } catch (...) {
99135       {
99136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99137       };
99138     }
99139   }
99140
99141 }
99142
99143
99144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
99145   int jresult ;
99146   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99147   int result;
99148
99149   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99150   {
99151     try {
99152       result = (int)(*arg1)->ReferenceCount();
99153     } catch (std::out_of_range& e) {
99154       {
99155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99156       };
99157     } catch (std::exception& e) {
99158       {
99159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99160       };
99161     } catch (Dali::DaliException e) {
99162       {
99163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99164       };
99165     } catch (...) {
99166       {
99167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99168       };
99169     }
99170   }
99171
99172   jresult = result;
99173   return jresult;
99174 }
99175
99176
99177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
99178   unsigned int jresult ;
99179   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99180   bool result;
99181
99182   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99183   {
99184     try {
99185       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99186     } catch (std::out_of_range& e) {
99187       {
99188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99189       };
99190     } catch (std::exception& e) {
99191       {
99192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99193       };
99194     } catch (Dali::DaliException e) {
99195       {
99196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99197       };
99198     } catch (...) {
99199       {
99200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99201       };
99202     }
99203   }
99204
99205   jresult = result;
99206   return jresult;
99207 }
99208
99209
99210 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
99211   unsigned long jresult ;
99212   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99213   std::size_t result;
99214
99215   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99216   {
99217     try {
99218       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99219     } catch (std::out_of_range& e) {
99220       {
99221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99222       };
99223     } catch (std::exception& e) {
99224       {
99225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99226       };
99227     } catch (Dali::DaliException e) {
99228       {
99229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99230       };
99231     } catch (...) {
99232       {
99233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99234       };
99235     }
99236   }
99237
99238   jresult = (unsigned long)result;
99239   return jresult;
99240 }
99241
99242
99243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
99244   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99245   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99246
99247   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99248   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99249   {
99250     try {
99251       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
99252     } catch (std::out_of_range& e) {
99253       {
99254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99255       };
99256     } catch (std::exception& e) {
99257       {
99258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99259       };
99260     } catch (Dali::DaliException e) {
99261       {
99262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99263       };
99264     } catch (...) {
99265       {
99266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99267       };
99268     }
99269   }
99270
99271 }
99272
99273
99274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
99275   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99276   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99277
99278   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99279   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99280   {
99281     try {
99282       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
99283     } catch (std::out_of_range& e) {
99284       {
99285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99286       };
99287     } catch (std::exception& e) {
99288       {
99289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99290       };
99291     } catch (Dali::DaliException e) {
99292       {
99293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99294       };
99295     } catch (...) {
99296       {
99297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99298       };
99299     }
99300   }
99301
99302 }
99303
99304
99305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
99306   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99307   Dali::Toolkit::Control arg2 ;
99308   Dali::Toolkit::Control *argp2 ;
99309
99310   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99311   argp2 = (Dali::Toolkit::Control *)jarg2;
99312   if (!argp2) {
99313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
99314     return ;
99315   }
99316   arg2 = *argp2;
99317   {
99318     try {
99319       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
99320     } catch (std::out_of_range& e) {
99321       {
99322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99323       };
99324     } catch (std::exception& e) {
99325       {
99326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99327       };
99328     } catch (Dali::DaliException e) {
99329       {
99330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99331       };
99332     } catch (...) {
99333       {
99334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99335       };
99336     }
99337   }
99338
99339 }
99340
99341
99342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
99343   void * jresult ;
99344   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
99345
99346   {
99347     try {
99348       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
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 = (void *)result;
99369   return jresult;
99370 }
99371
99372
99373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
99374   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99375
99376   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99377   {
99378     try {
99379       delete arg1;
99380     } catch (std::out_of_range& e) {
99381       {
99382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99383       };
99384     } catch (std::exception& e) {
99385       {
99386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99387       };
99388     } catch (Dali::DaliException e) {
99389       {
99390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99391       };
99392     } catch (...) {
99393       {
99394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99395       };
99396     }
99397   }
99398
99399 }
99400
99401 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
99402   Dali::RefObject *result = NULL;
99403
99404   if (arg1)
99405   {
99406     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
99407   }
99408   return result;
99409 }
99410
99411 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
99412     return (Dali::RefObject *)jarg1;
99413 }
99414
99415 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
99416     return (Dali::SignalObserver *)jarg1;
99417 }
99418
99419 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
99420     return (Dali::ConnectionTrackerInterface *)jarg1;
99421 }
99422
99423 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
99424     return (Dali::BaseHandle *)jarg1;
99425 }
99426
99427 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
99428     return (Dali::BaseHandle *)jarg1;
99429 }
99430
99431 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
99432     return (Dali::BaseHandle *)jarg1;
99433 }
99434
99435 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
99436     return (Dali::BaseHandle *)jarg1;
99437 }
99438
99439 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
99440     return (Dali::BaseHandle *)jarg1;
99441 }
99442
99443 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
99444     return (Dali::BaseHandle *)jarg1;
99445 }
99446
99447 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
99448     return (Dali::BaseHandle *)jarg1;
99449 }
99450
99451 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
99452     return (Dali::BaseHandle *)jarg1;
99453 }
99454
99455 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
99456     return (Dali::BaseHandle *)jarg1;
99457 }
99458
99459 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
99460     return (Dali::BaseHandle *)jarg1;
99461 }
99462
99463 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
99464     return (Dali::BaseHandle *)jarg1;
99465 }
99466
99467 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
99468     return (Dali::BaseHandle *)jarg1;
99469 }
99470
99471 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
99472     return (Dali::BaseHandle *)jarg1;
99473 }
99474
99475 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
99476     return (Dali::Handle *)jarg1;
99477 }
99478
99479 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
99480     return (Dali::Handle *)jarg1;
99481 }
99482
99483 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
99484     return (Dali::BaseHandle *)jarg1;
99485 }
99486
99487 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
99488     return (Dali::BaseHandle *)jarg1;
99489 }
99490
99491 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
99492     return (Dali::Handle *)jarg1;
99493 }
99494
99495 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
99496     return (Dali::BaseHandle *)jarg1;
99497 }
99498
99499 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
99500     return (Dali::Handle *)jarg1;
99501 }
99502
99503 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
99504     return (Dali::GestureDetector *)jarg1;
99505 }
99506
99507 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
99508     return (Dali::Gesture *)jarg1;
99509 }
99510
99511 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
99512     return (Dali::Handle *)jarg1;
99513 }
99514
99515 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
99516     return (Dali::Actor *)jarg1;
99517 }
99518
99519 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
99520     return (Dali::BaseHandle *)jarg1;
99521 }
99522
99523 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
99524     return (Dali::RefObject *)jarg1;
99525 }
99526
99527 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
99528     return (Dali::Actor *)jarg1;
99529 }
99530
99531 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
99532     return (Dali::GestureDetector *)jarg1;
99533 }
99534
99535 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
99536     return (Dali::Gesture *)jarg1;
99537 }
99538
99539 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
99540     return (Dali::GestureDetector *)jarg1;
99541 }
99542
99543 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
99544     return (Dali::Gesture *)jarg1;
99545 }
99546
99547 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
99548     return (Dali::GestureDetector *)jarg1;
99549 }
99550
99551 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
99552     return (Dali::Gesture *)jarg1;
99553 }
99554
99555 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
99556     return (Dali::BaseHandle *)jarg1;
99557 }
99558
99559 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
99560     return (Dali::Handle *)jarg1;
99561 }
99562
99563 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
99564     return (Dali::Handle *)jarg1;
99565 }
99566
99567 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
99568     return (Dali::Handle *)jarg1;
99569 }
99570
99571 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
99572     return (Dali::Image *)jarg1;
99573 }
99574
99575 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
99576     return (Dali::Image *)jarg1;
99577 }
99578
99579 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
99580     return (Dali::Image *)jarg1;
99581 }
99582
99583 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
99584     return (Dali::RefObject *)jarg1;
99585 }
99586
99587 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
99588     return (Dali::Image *)jarg1;
99589 }
99590
99591 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
99592     return (Dali::Image *)jarg1;
99593 }
99594
99595 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
99596     return (Dali::ResourceImage *)jarg1;
99597 }
99598
99599 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
99600     return (Dali::Actor *)jarg1;
99601 }
99602
99603 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
99604     return (Dali::BaseHandle *)jarg1;
99605 }
99606
99607 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
99608     return (Dali::BaseHandle *)jarg1;
99609 }
99610
99611 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
99612     return (Dali::BaseHandle *)jarg1;
99613 }
99614
99615 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
99616     return (Dali::CustomActorImpl *)jarg1;
99617 }
99618
99619 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
99620     return (Dali::CustomActor *)jarg1;
99621 }
99622
99623 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
99624     return (Dali::BaseHandle *)jarg1;
99625 }
99626
99627 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
99628     return (Dali::Toolkit::Control *)jarg1;
99629 }
99630
99631 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
99632     return (Dali::Toolkit::Control *)jarg1;
99633 }
99634
99635 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
99636     return (Dali::Toolkit::Button *)jarg1;
99637 }
99638
99639 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
99640     return (Dali::Toolkit::Button *)jarg1;
99641 }
99642
99643 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
99644     return (Dali::Toolkit::Button *)jarg1;
99645 }
99646
99647 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
99648     return (Dali::Toolkit::Control *)jarg1;
99649 }
99650
99651 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
99652     return (Dali::Toolkit::Control *)jarg1;
99653 }
99654
99655 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
99656     return (Dali::Toolkit::Control *)jarg1;
99657 }
99658
99659 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
99660     return (Dali::Toolkit::Control *)jarg1;
99661 }
99662
99663 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
99664     return (Dali::Toolkit::Control *)jarg1;
99665 }
99666
99667 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
99668     return (Dali::RefObject *)jarg1;
99669 }
99670
99671 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
99672     return (Dali::Toolkit::Scrollable *)jarg1;
99673 }
99674
99675 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
99676     return (Dali::BaseHandle *)jarg1;
99677 }
99678
99679 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
99680     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
99681 }
99682
99683 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
99684     return (Dali::RefObject *)jarg1;
99685 }
99686
99687 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
99688     return (Dali::Toolkit::Ruler *)jarg1;
99689 }
99690
99691 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
99692     return (Dali::Toolkit::Ruler *)jarg1;
99693 }
99694
99695 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
99696     return (Dali::Toolkit::Scrollable *)jarg1;
99697 }
99698
99699 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
99700     return (Dali::Toolkit::Control *)jarg1;
99701 }
99702
99703
99704 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
99705     return (Dali::Toolkit::Control *)jarg1;
99706 }
99707
99708 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
99709     return (Dali::BaseHandle *)jarg1;
99710 }
99711
99712 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
99713     return (Dali::BaseHandle *)jarg1;
99714 }
99715
99716 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
99717     return (Dali::Toolkit::Control *)jarg1;
99718 }
99719
99720 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
99721     return (Dali::Toolkit::Control *)jarg1;
99722 }
99723
99724 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
99725     return (Dali::Toolkit::Control *)jarg1;
99726 }
99727
99728 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
99729     return (Dali::Toolkit::Control *)jarg1;
99730 }
99731
99732 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
99733     return (Dali::Toolkit::Control *)jarg1;
99734 }
99735
99736 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
99737     return (Dali::Toolkit::Control *)jarg1;
99738 }
99739
99740 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
99741     return (Dali::Toolkit::PageTurnView *)jarg1;
99742 }
99743
99744 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
99745     return (Dali::Toolkit::PageTurnView *)jarg1;
99746 }
99747
99748 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
99749     return (Dali::Toolkit::Button *)jarg1;
99750 }
99751
99752 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
99753     return (Dali::BaseHandle *)jarg1;
99754 }
99755
99756 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
99757     return (Dali::BaseHandle *)jarg1;
99758 }
99759
99760 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
99761     return (Dali::BaseHandle *)jarg1;
99762 }
99763
99764 /*
99765  * Widget binding
99766  */
99767 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
99768     return (Dali::BaseHandle *)jarg1;
99769 }
99770
99771 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
99772     return (Dali::BaseObject *)jarg1;
99773 }
99774
99775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
99776   void * jresult ;
99777   Dali::Widget result;
99778
99779   {
99780     try {
99781       result = Dali::Widget::New();
99782     } catch (std::out_of_range& e) {
99783       {
99784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99785       };
99786     } catch (std::exception& e) {
99787       {
99788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99789       };
99790     } catch (...) {
99791       {
99792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99793       };
99794     }
99795   }
99796   jresult = new Dali::Widget((const Dali::Widget &)result);
99797   return jresult;
99798 }
99799
99800
99801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
99802   void * jresult ;
99803   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
99804   Dali::Widget result;
99805
99806   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99807
99808   if (!arg1) {
99809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
99810     return 0;
99811   }
99812   {
99813     try {
99814       jresult = new Dali::Widget(arg1);
99815     } catch (std::out_of_range& e) {
99816       {
99817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99818       };
99819     } catch (std::exception& e) {
99820       {
99821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99822       };
99823     } catch (...) {
99824       {
99825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99826       };
99827     }
99828   }
99829   return jresult;
99830 }
99831
99832
99833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
99834   void * jresult ;
99835   Dali::Widget *result = 0 ;
99836
99837   {
99838     try {
99839       result = (Dali::Widget *)new Dali::Widget();
99840     } catch (std::out_of_range& e) {
99841       {
99842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99843       };
99844     } catch (std::exception& e) {
99845       {
99846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99847       };
99848     } catch (...) {
99849       {
99850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99851       };
99852     }
99853   }
99854   jresult = (void *)result;
99855   return jresult;
99856 }
99857
99858
99859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
99860   void * jresult ;
99861   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
99862   Dali::Widget *arg2 = 0 ;
99863   Dali::Widget *result = 0 ;
99864
99865   arg1 = (Dali::Widget *)jarg1;
99866   arg2 = (Dali::Widget *)jarg2;
99867   if (!arg2) {
99868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
99869     return 0;
99870   }
99871   {
99872     try {
99873       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
99874     } catch (std::out_of_range& e) {
99875       {
99876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99877       };
99878     } catch (std::exception& e) {
99879       {
99880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99881       };
99882     } catch (...) {
99883       {
99884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99885       };
99886     }
99887   }
99888   jresult = (void *)result;
99889   return jresult;
99890 }
99891
99892
99893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
99894   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
99895
99896   arg1 = (Dali::Widget *)jarg1;
99897   {
99898     try {
99899       delete arg1;
99900     } catch (std::out_of_range& e) {
99901       {
99902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99903       };
99904     } catch (std::exception& e) {
99905       {
99906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99907       };
99908     } catch (...) {
99909       {
99910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99911       };
99912     }
99913   }
99914 }
99915
99916
99917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
99918   void * jresult ;
99919   SwigDirector_WidgetImpl* result;
99920   {
99921     try {
99922       result = new SwigDirector_WidgetImpl();
99923     } catch (std::out_of_range& e) {
99924       {
99925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99926       };
99927     } catch (std::exception& e) {
99928       {
99929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99930       };
99931     } catch (...) {
99932       {
99933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99934       };
99935     }
99936   }
99937   jresult = result;
99938   return jresult;
99939 }
99940
99941
99942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
99943   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99944   std::string *arg2 = 0 ;
99945   Dali::Window arg3 ;
99946   Dali::Window *argp3 ;
99947
99948   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99949   if (!jarg2) {
99950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99951     return ;
99952   }
99953   std::string arg2_str(jarg2);
99954   arg2 = &arg2_str;
99955   argp3 = (Dali::Window *)jarg3;
99956   if (!argp3) {
99957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
99958     return ;
99959   }
99960   arg3 = *argp3;
99961   {
99962     try {
99963       (arg1)->OnCreate((std::string const &)*arg2,arg3);
99964     } catch (std::out_of_range& e) {
99965       {
99966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99967       };
99968     } catch (std::exception& e) {
99969       {
99970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99971       };
99972     } catch (...) {
99973       {
99974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99975       };
99976     }
99977   }
99978 }
99979
99980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
99981   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99982   std::string *arg2 = 0 ;
99983   Dali::Window arg3 ;
99984   Dali::Window *argp3 ;
99985
99986   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99987   if (!jarg2) {
99988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99989     return ;
99990   }
99991   std::string arg2_str(jarg2);
99992   arg2 = &arg2_str;
99993   argp3 = (Dali::Window *)jarg3;
99994   if (!argp3) {
99995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
99996     return ;
99997   }
99998   arg3 = *argp3;
99999   {
100000     try {
100001       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
100002     } catch (std::out_of_range& e) {
100003       {
100004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100005       };
100006     } catch (std::exception& e) {
100007       {
100008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100009       };
100010     } catch (...) {
100011       {
100012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100013       };
100014     }
100015   }
100016 }
100017
100018
100019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
100020   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100021   std::string *arg2 = 0 ;
100022   Dali::Widget::Termination arg3 ;
100023
100024   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100025   if (!jarg2) {
100026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100027     return ;
100028   }
100029   std::string arg2_str(jarg2);
100030   arg2 = &arg2_str;
100031   arg3 = (Dali::Widget::Termination)jarg3;
100032   {
100033     try {
100034       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
100035     } catch (std::out_of_range& e) {
100036       {
100037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100038       };
100039     } catch (std::exception& e) {
100040       {
100041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100042       };
100043     } catch (...) {
100044       {
100045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100046       };
100047     }
100048   }
100049 }
100050
100051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100052   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100053   std::string *arg2 = 0 ;
100054   Dali::Widget::Termination arg3 ;
100055
100056   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100057   if (!jarg2) {
100058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100059     return ;
100060   }
100061   std::string arg2_str(jarg2);
100062   arg2 = &arg2_str;
100063   arg3 = (Dali::Widget::Termination)jarg3;
100064   {
100065     try {
100066       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
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 (...) {
100076       {
100077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100078       };
100079     }
100080   }
100081 }
100082
100083
100084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
100085   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100086
100087   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100088   {
100089     try {
100090       (arg1)->OnPause();
100091     } catch (std::out_of_range& e) {
100092       {
100093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100094       };
100095     } catch (std::exception& e) {
100096       {
100097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100098       };
100099     } catch (...) {
100100       {
100101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100102       };
100103     }
100104   }
100105 }
100106
100107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
100108   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100109
100110   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100111   {
100112     try {
100113       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
100114     } catch (std::out_of_range& e) {
100115       {
100116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100117       };
100118     } catch (std::exception& e) {
100119       {
100120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100121       };
100122     } catch (...) {
100123       {
100124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100125       };
100126     }
100127   }
100128 }
100129
100130
100131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
100132   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100133
100134   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100135   {
100136     try {
100137       (arg1)->OnResume();
100138     } catch (std::out_of_range& e) {
100139       {
100140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100141       };
100142     } catch (std::exception& e) {
100143       {
100144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100145       };
100146     } catch (...) {
100147       {
100148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100149       };
100150     }
100151   }
100152 }
100153
100154
100155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
100156   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100157
100158   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100159   {
100160     try {
100161       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
100162     } catch (std::out_of_range& e) {
100163       {
100164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100165       };
100166     } catch (std::exception& e) {
100167       {
100168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100169       };
100170     } catch (...) {
100171       {
100172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100173       };
100174     }
100175   }
100176 }
100177
100178
100179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
100180   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100181   Dali::Window arg2 ;
100182   Dali::Window *argp2 ;
100183
100184   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100185   argp2 = (Dali::Window *)jarg2;
100186   if (!argp2) {
100187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100188     return ;
100189   }
100190   arg2 = *argp2;
100191   {
100192     try {
100193       (arg1)->OnResize(arg2);
100194     } catch (std::out_of_range& e) {
100195       {
100196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100197       };
100198     } catch (std::exception& e) {
100199       {
100200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100201       };
100202     } catch (...) {
100203       {
100204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100205       };
100206     }
100207   }
100208 }
100209
100210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
100211   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100212   Dali::Window arg2 ;
100213   Dali::Window *argp2 ;
100214
100215   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100216   argp2 = (Dali::Window *)jarg2;
100217   if (!argp2) {
100218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100219     return ;
100220   }
100221   arg2 = *argp2;
100222   {
100223     try {
100224       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
100225     } catch (std::out_of_range& e) {
100226       {
100227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100228       };
100229     } catch (std::exception& e) {
100230       {
100231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100232       };
100233     } catch (...) {
100234       {
100235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100236       };
100237     }
100238   }
100239 }
100240
100241
100242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
100243   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100244   std::string *arg2 = 0 ;
100245   int arg3 ;
100246
100247   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100248   if (!jarg2) {
100249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100250     return ;
100251   }
100252   std::string arg2_str(jarg2);
100253   arg2 = &arg2_str;
100254   arg3 = (int)jarg3;
100255   {
100256     try {
100257       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
100258     } catch (std::out_of_range& e) {
100259       {
100260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100261       };
100262     } catch (std::exception& e) {
100263       {
100264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100265       };
100266     } catch (...) {
100267       {
100268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100269       };
100270     }
100271   }
100272 }
100273
100274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100275   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100276   std::string *arg2 = 0 ;
100277   int arg3 ;
100278
100279   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100280   if (!jarg2) {
100281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100282     return ;
100283   }
100284   std::string arg2_str(jarg2);
100285   arg2 = &arg2_str;
100286   arg3 = (int)jarg3;
100287   {
100288     try {
100289       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
100290     } catch (std::out_of_range& e) {
100291       {
100292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100293       };
100294     } catch (std::exception& e) {
100295       {
100296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100297       };
100298     } catch (...) {
100299       {
100300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100301       };
100302     }
100303   }
100304 }
100305
100306
100307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
100308   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100309   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100310   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100311
100312   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100313   arg2 = (Dali::SlotObserver *)jarg2;
100314   arg3 = (Dali::CallbackBase *)jarg3;
100315   {
100316     try {
100317       (arg1)->SignalConnected(arg2,arg3);
100318     } catch (std::out_of_range& e) {
100319       {
100320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100321       };
100322     } catch (std::exception& e) {
100323       {
100324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100325       };
100326     } catch (...) {
100327       {
100328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100329       };
100330     }
100331   }
100332 }
100333
100334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100335   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100336   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100337   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100338
100339   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100340   arg2 = (Dali::SlotObserver *)jarg2;
100341   arg3 = (Dali::CallbackBase *)jarg3;
100342   {
100343     try {
100344       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
100345     } catch (std::out_of_range& e) {
100346       {
100347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100348       };
100349     } catch (std::exception& e) {
100350       {
100351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100352       };
100353     } catch (...) {
100354       {
100355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100356       };
100357     }
100358   }
100359 }
100360
100361
100362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
100363   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100364   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100365   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100366
100367   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100368   arg2 = (Dali::SlotObserver *)jarg2;
100369   arg3 = (Dali::CallbackBase *)jarg3;
100370   {
100371     try {
100372       (arg1)->SignalDisconnected(arg2,arg3);
100373     } catch (std::out_of_range& e) {
100374       {
100375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100376       };
100377     } catch (std::exception& e) {
100378       {
100379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100380       };
100381     } catch (...) {
100382       {
100383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100384       };
100385     }
100386   }
100387 }
100388
100389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100390   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100391   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100392   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100393
100394   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100395   arg2 = (Dali::SlotObserver *)jarg2;
100396   arg3 = (Dali::CallbackBase *)jarg3;
100397   {
100398     try {
100399       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
100400     } catch (std::out_of_range& e) {
100401       {
100402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100403       };
100404     } catch (std::exception& e) {
100405       {
100406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100407       };
100408     } catch (...) {
100409       {
100410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100411       };
100412     }
100413   }
100414 }
100415
100416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
100417   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100418   std::string *arg2 = 0 ;
100419
100420   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100421   if (!jarg2) {
100422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100423     return ;
100424   }
100425   std::string arg2_str(jarg2);
100426   arg2 = &arg2_str;
100427   {
100428     try {
100429       (arg1)->SetContentInfo((std::string const &)*arg2);
100430     } catch (std::out_of_range& e) {
100431       {
100432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100433       };
100434     } catch (std::exception& e) {
100435       {
100436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100437       };
100438     } catch (...) {
100439       {
100440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100441       };
100442     }
100443   }
100444 }
100445
100446
100447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
100448   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100449   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
100450
100451   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100452   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
100453   {
100454     try {
100455       (arg1)->SetImpl(arg2);
100456     } catch (std::out_of_range& e) {
100457       {
100458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100459       };
100460     } catch (std::exception& e) {
100461       {
100462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100463       };
100464     } catch (...) {
100465       {
100466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100467       };
100468     }
100469   }
100470 }
100471
100472 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) {
100473
100474   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
100475   if (director) {
100476     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
100477   }
100478 }
100479
100480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
100481   void * jresult ;
100482   Dali::Widget *arg1 = 0 ;
100483   SwigDirector_WidgetImpl *result = 0 ;
100484
100485   arg1 = (Dali::Widget *)jarg1;
100486   if (!arg1) {
100487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
100488     return 0;
100489   }
100490   {
100491     try {
100492       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
100493     } catch (std::out_of_range& e) {
100494       {
100495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100496       };
100497     } catch (std::exception& e) {
100498       {
100499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100500       };
100501     } catch (...) {
100502       {
100503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100504       };
100505     }
100506   }
100507
100508   jresult = (void *)result;
100509   return jresult;
100510 }
100511
100512
100513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
100514   void * jresult ;
100515   int *arg1 = (int *) 0 ;
100516   char ***arg2 ;
100517   std::string *arg3 = 0 ;
100518   Dali::WidgetApplication result;
100519   {
100520     int index = 0;
100521     int length = 0;
100522     char *retPtr;
100523     char *nextPtr;
100524     argWidgetC = jarg1;
100525     argWidgetV = new char*[jarg1 + 1];
100526
100527     retPtr = strtok_r( jarg2, " ", &nextPtr);
100528     if( retPtr )
100529     {
100530       length = strlen(retPtr);
100531     }
100532     argWidgetV[index] = new char[length + 1];
100533     if( retPtr )
100534     {
100535       strncpy(argWidgetV[index], retPtr, length);
100536     }
100537     argWidgetV[index][length] = '\0';
100538     index++;
100539
100540     while (index < jarg1)
100541     {
100542       length = 0;
100543       retPtr = strtok_r(NULL, " ", &nextPtr);
100544       if( retPtr )
100545       {
100546         length = strlen(retPtr);
100547       }
100548       argWidgetV[index] = new char[length + 1];
100549       if( retPtr )
100550       {
100551         strncpy(argWidgetV[index], retPtr, length);
100552       }
100553       argWidgetV[index][length] = '\0';
100554       index++;
100555     }
100556
100557     argWidgetV[jarg1] = NULL;
100558     argWidgetC = jarg1;
100559
100560     arg1 = &argWidgetC;
100561     arg2 = &argWidgetV;
100562   }
100563
100564   if (!jarg3) {
100565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100566     return 0;
100567   }
100568   std::string arg3_str(jarg3);
100569   arg3 = &arg3_str;
100570   {
100571     try {
100572       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
100573     } catch (std::out_of_range& e) {
100574       {
100575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100576       };
100577     } catch (std::exception& e) {
100578       {
100579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100580       };
100581     } catch (...) {
100582       {
100583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100584       };
100585     }
100586   }
100587   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
100588
100589   return jresult;
100590 }
100591
100592
100593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
100594   void * jresult ;
100595   Dali::WidgetApplication *result = 0 ;
100596
100597   {
100598     try {
100599       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
100600     } catch (std::out_of_range& e) {
100601       {
100602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100603       };
100604     } catch (std::exception& e) {
100605       {
100606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100607       };
100608     } catch (...) {
100609       {
100610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100611       };
100612     }
100613   }
100614   jresult = (void *)result;
100615   return jresult;
100616 }
100617
100618
100619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
100620   void * jresult ;
100621   Dali::WidgetApplication *arg1 = 0 ;
100622   Dali::WidgetApplication *result = 0 ;
100623
100624   arg1 = (Dali::WidgetApplication *)jarg1;
100625   if (!arg1) {
100626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100627     return 0;
100628   }
100629   {
100630     try {
100631       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
100632     } catch (std::out_of_range& e) {
100633       {
100634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100635       };
100636     } catch (std::exception& e) {
100637       {
100638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100639       };
100640     } catch (...) {
100641       {
100642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100643       };
100644     }
100645   }
100646   jresult = (void *)result;
100647   return jresult;
100648 }
100649
100650
100651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
100652   void * jresult ;
100653   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100654   Dali::WidgetApplication *arg2 = 0 ;
100655   Dali::WidgetApplication *result = 0 ;
100656
100657   arg1 = (Dali::WidgetApplication *)jarg1;
100658   arg2 = (Dali::WidgetApplication *)jarg2;
100659   if (!arg2) {
100660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100661     return 0;
100662   }
100663   {
100664     try {
100665       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
100666     } catch (std::out_of_range& e) {
100667       {
100668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100669       };
100670     } catch (std::exception& e) {
100671       {
100672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100673       };
100674     } catch (...) {
100675       {
100676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100677       };
100678     }
100679   }
100680   jresult = (void *)result;
100681   return jresult;
100682 }
100683
100684
100685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
100686   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100687
100688   arg1 = (Dali::WidgetApplication *)jarg1;
100689   {
100690     try {
100691       delete arg1;
100692       if( argWidgetV )
100693       {
100694         // free string data
100695         for( int i=0; i < argWidgetC+1; i++)
100696         {
100697           delete [] argWidgetV[i];
100698         }
100699         delete [] argWidgetV;
100700       }
100701     } catch (std::out_of_range& e) {
100702       {
100703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100704       };
100705     } catch (std::exception& e) {
100706       {
100707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100708       };
100709     } catch (...) {
100710       {
100711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100712       };
100713     }
100714   }
100715 }
100716
100717
100718 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
100719 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
100720
100721 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
100722 {
100723   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
100724   return *widget;
100725 }
100726
100727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
100728   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100729   std::string *arg2 = 0 ;
100730
100731   arg1 = (Dali::WidgetApplication *)jarg1;
100732   if (!jarg2) {
100733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100734     return ;
100735   }
100736   std::string arg2_str(*jarg2);
100737   arg2 = &arg2_str;
100738
100739   if(!_CSharpCreateWidgetFunction)
100740   {
100741     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
100742   }
100743
100744   {
100745     try {
100746       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
100747     } catch (std::out_of_range& e) {
100748       {
100749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100750       };
100751     } catch (std::exception& e) {
100752       {
100753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100754       };
100755     } catch (...) {
100756       {
100757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100758       };
100759     }
100760   }
100761
100762   //Typemap argout in c++ file.
100763   //This will convert c++ string to c# string
100764   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
100765 }
100766
100767
100768 //for PixelBuffer and ImageLoading
100769
100770 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
100771     return (Dali::BaseHandle *)jarg1;
100772 }
100773
100774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
100775   void * jresult ;
100776   unsigned int arg1 ;
100777   unsigned int arg2 ;
100778   Dali::Pixel::Format arg3 ;
100779   Dali::Devel::PixelBuffer result;
100780
100781   arg1 = (unsigned int)jarg1;
100782   arg2 = (unsigned int)jarg2;
100783   arg3 = (Dali::Pixel::Format)jarg3;
100784   {
100785     try {
100786       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
100787     } catch (std::out_of_range& e) {
100788       {
100789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100790       };
100791     } catch (std::exception& e) {
100792       {
100793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100794       };
100795     } catch (...) {
100796       {
100797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100798       };
100799     }
100800   }
100801   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100802   return jresult;
100803 }
100804
100805
100806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
100807   void * jresult ;
100808   Dali::Devel::PixelBuffer *result = 0 ;
100809
100810   {
100811     try {
100812       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
100813     } catch (std::out_of_range& e) {
100814       {
100815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100816       };
100817     } catch (std::exception& e) {
100818       {
100819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100820       };
100821     } catch (...) {
100822       {
100823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100824       };
100825     }
100826   }
100827   jresult = (void *)result;
100828   return jresult;
100829 }
100830
100831
100832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
100833   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100834
100835   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100836   {
100837     try {
100838       delete arg1;
100839     } catch (std::out_of_range& e) {
100840       {
100841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100842       };
100843     } catch (std::exception& e) {
100844       {
100845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100846       };
100847     } catch (...) {
100848       {
100849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100850       };
100851     }
100852   }
100853 }
100854
100855
100856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
100857   void * jresult ;
100858   Dali::Devel::PixelBuffer *arg1 = 0 ;
100859   Dali::Devel::PixelBuffer *result = 0 ;
100860
100861   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100862   if (!arg1) {
100863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
100864     return 0;
100865   }
100866   {
100867     try {
100868       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
100869     } catch (std::out_of_range& e) {
100870       {
100871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100872       };
100873     } catch (std::exception& e) {
100874       {
100875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100876       };
100877     } catch (...) {
100878       {
100879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100880       };
100881     }
100882   }
100883   jresult = (void *)result;
100884   return jresult;
100885 }
100886
100887
100888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
100889   void * jresult ;
100890   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100891   Dali::Devel::PixelBuffer *arg2 = 0 ;
100892   Dali::Devel::PixelBuffer *result = 0 ;
100893
100894   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100895   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
100896   if (!arg2) {
100897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
100898     return 0;
100899   }
100900   {
100901     try {
100902       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
100903     } catch (std::out_of_range& e) {
100904       {
100905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100906       };
100907     } catch (std::exception& e) {
100908       {
100909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100910       };
100911     } catch (...) {
100912       {
100913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100914       };
100915     }
100916   }
100917   jresult = (void *)result;
100918   return jresult;
100919 }
100920
100921
100922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
100923   void * jresult ;
100924   Dali::Devel::PixelBuffer *arg1 = 0 ;
100925   Dali::PixelData result;
100926
100927   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100928   if (!arg1) {
100929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
100930     return 0;
100931   }
100932   {
100933     try {
100934       result = Dali::Devel::PixelBuffer::Convert(*arg1);
100935     } catch (std::out_of_range& e) {
100936       {
100937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100938       };
100939     } catch (std::exception& e) {
100940       {
100941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100942       };
100943     } catch (...) {
100944       {
100945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100946       };
100947     }
100948   }
100949   jresult = new Dali::PixelData((const Dali::PixelData &)result);
100950   return jresult;
100951 }
100952
100953
100954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
100955   void * jresult ;
100956   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100957   Dali::PixelData result;
100958
100959   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100960   {
100961     try {
100962       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
100963     } catch (std::out_of_range& e) {
100964       {
100965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100966       };
100967     } catch (std::exception& e) {
100968       {
100969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100970       };
100971     } catch (...) {
100972       {
100973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100974       };
100975     }
100976   }
100977   jresult = new Dali::PixelData((const Dali::PixelData &)result);
100978   return jresult;
100979 }
100980
100981
100982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
100983   void * jresult ;
100984   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100985   unsigned char *result = 0 ;
100986
100987   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100988   {
100989     try {
100990       result = (unsigned char *)(arg1)->GetBuffer();
100991     } catch (std::out_of_range& e) {
100992       {
100993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100994       };
100995     } catch (std::exception& e) {
100996       {
100997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100998       };
100999     } catch (...) {
101000       {
101001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101002       };
101003     }
101004   }
101005   jresult = (void *)result;
101006   return jresult;
101007 }
101008
101009
101010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
101011   unsigned int jresult ;
101012   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101013   unsigned int result;
101014
101015   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101016   {
101017     try {
101018       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
101019     } catch (std::out_of_range& e) {
101020       {
101021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101022       };
101023     } catch (std::exception& e) {
101024       {
101025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101026       };
101027     } catch (...) {
101028       {
101029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101030       };
101031     }
101032   }
101033   jresult = result;
101034   return jresult;
101035 }
101036
101037
101038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
101039   unsigned int jresult ;
101040   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101041   unsigned int result;
101042
101043   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101044   {
101045     try {
101046       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
101047     } catch (std::out_of_range& e) {
101048       {
101049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101050       };
101051     } catch (std::exception& e) {
101052       {
101053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101054       };
101055     } catch (...) {
101056       {
101057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101058       };
101059     }
101060   }
101061   jresult = result;
101062   return jresult;
101063 }
101064
101065
101066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
101067   int jresult ;
101068   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101069   Dali::Pixel::Format result;
101070
101071   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101072   {
101073     try {
101074       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
101075     } catch (std::out_of_range& e) {
101076       {
101077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101078       };
101079     } catch (std::exception& e) {
101080       {
101081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101082       };
101083     } catch (...) {
101084       {
101085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101086       };
101087     }
101088   }
101089   jresult = (int)result;
101090   return jresult;
101091 }
101092
101093
101094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
101095   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101096   Dali::Devel::PixelBuffer arg2 ;
101097   float arg3 ;
101098   bool arg4 ;
101099   Dali::Devel::PixelBuffer *argp2 ;
101100
101101   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101102   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101103   if (!argp2) {
101104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101105     return ;
101106   }
101107   arg2 = *argp2;
101108   arg3 = (float)jarg3;
101109   arg4 = jarg4 ? true : false;
101110   {
101111     try {
101112       (arg1)->ApplyMask(arg2,arg3,arg4);
101113     } catch (std::out_of_range& e) {
101114       {
101115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101116       };
101117     } catch (std::exception& e) {
101118       {
101119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101120       };
101121     } catch (...) {
101122       {
101123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101124       };
101125     }
101126   }
101127 }
101128
101129
101130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
101131   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101132   Dali::Devel::PixelBuffer arg2 ;
101133   float arg3 ;
101134   Dali::Devel::PixelBuffer *argp2 ;
101135
101136   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101137   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101138   if (!argp2) {
101139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101140     return ;
101141   }
101142   arg2 = *argp2;
101143   arg3 = (float)jarg3;
101144   {
101145     try {
101146       (arg1)->ApplyMask(arg2,arg3);
101147     } catch (std::out_of_range& e) {
101148       {
101149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101150       };
101151     } catch (std::exception& e) {
101152       {
101153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101154       };
101155     } catch (...) {
101156       {
101157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101158       };
101159     }
101160   }
101161 }
101162
101163
101164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
101165   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101166   Dali::Devel::PixelBuffer arg2 ;
101167   Dali::Devel::PixelBuffer *argp2 ;
101168
101169   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101170   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101171   if (!argp2) {
101172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101173     return ;
101174   }
101175   arg2 = *argp2;
101176   {
101177     try {
101178       (arg1)->ApplyMask(arg2);
101179     } catch (std::out_of_range& e) {
101180       {
101181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101182       };
101183     } catch (std::exception& e) {
101184       {
101185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101186       };
101187     } catch (...) {
101188       {
101189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101190       };
101191     }
101192   }
101193 }
101194
101195
101196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
101197   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101198   float arg2 ;
101199
101200   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101201   arg2 = (float)jarg2;
101202   {
101203     try {
101204       (arg1)->ApplyGaussianBlur(arg2);
101205     } catch (std::out_of_range& e) {
101206       {
101207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101208       };
101209     } catch (std::exception& e) {
101210       {
101211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101212       };
101213     } catch (...) {
101214       {
101215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101216       };
101217     }
101218   }
101219 }
101220
101221
101222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
101223   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101224   uint16_t arg2 ;
101225   uint16_t arg3 ;
101226   uint16_t arg4 ;
101227   uint16_t arg5 ;
101228
101229   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101230   arg2 = (uint16_t)jarg2;
101231   arg3 = (uint16_t)jarg3;
101232   arg4 = (uint16_t)jarg4;
101233   arg5 = (uint16_t)jarg5;
101234   {
101235     try {
101236       (arg1)->Crop(arg2,arg3,arg4,arg5);
101237     } catch (std::out_of_range& e) {
101238       {
101239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101240       };
101241     } catch (std::exception& e) {
101242       {
101243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101244       };
101245     } catch (...) {
101246       {
101247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101248       };
101249     }
101250   }
101251 }
101252
101253
101254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
101255   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101256   uint16_t arg2 ;
101257   uint16_t arg3 ;
101258
101259   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101260   arg2 = (uint16_t)jarg2;
101261   arg3 = (uint16_t)jarg3;
101262   {
101263     try {
101264       (arg1)->Resize(arg2,arg3);
101265     } catch (std::out_of_range& e) {
101266       {
101267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101268       };
101269     } catch (std::exception& e) {
101270       {
101271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101272       };
101273     } catch (...) {
101274       {
101275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101276       };
101277     }
101278   }
101279 }
101280
101281
101282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101283   void * jresult ;
101284   std::string *arg1 = 0 ;
101285   Dali::ImageDimensions arg2 ;
101286   Dali::FittingMode::Type arg3 ;
101287   Dali::SamplingMode::Type arg4 ;
101288   bool arg5 ;
101289   Dali::ImageDimensions *argp2 ;
101290   Dali::Devel::PixelBuffer result;
101291
101292   if (!jarg1) {
101293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101294     return 0;
101295   }
101296   std::string arg1_str(jarg1);
101297   arg1 = &arg1_str;
101298   argp2 = (Dali::ImageDimensions *)jarg2;
101299   if (!argp2) {
101300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101301     return 0;
101302   }
101303   arg2 = *argp2;
101304   arg3 = (Dali::FittingMode::Type)jarg3;
101305   arg4 = (Dali::SamplingMode::Type)jarg4;
101306   arg5 = jarg5 ? true : false;
101307   {
101308     try {
101309       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101310     } catch (std::out_of_range& e) {
101311       {
101312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101313       };
101314     } catch (std::exception& e) {
101315       {
101316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101317       };
101318     } catch (...) {
101319       {
101320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101321       };
101322     }
101323   }
101324   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101325
101326   return jresult;
101327 }
101328
101329
101330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101331   void * jresult ;
101332   std::string *arg1 = 0 ;
101333   Dali::ImageDimensions arg2 ;
101334   Dali::FittingMode::Type arg3 ;
101335   Dali::SamplingMode::Type arg4 ;
101336   Dali::ImageDimensions *argp2 ;
101337   Dali::Devel::PixelBuffer result;
101338
101339   if (!jarg1) {
101340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101341     return 0;
101342   }
101343   std::string arg1_str(jarg1);
101344   arg1 = &arg1_str;
101345   argp2 = (Dali::ImageDimensions *)jarg2;
101346   if (!argp2) {
101347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101348     return 0;
101349   }
101350   arg2 = *argp2;
101351   arg3 = (Dali::FittingMode::Type)jarg3;
101352   arg4 = (Dali::SamplingMode::Type)jarg4;
101353   {
101354     try {
101355       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
101356     } catch (std::out_of_range& e) {
101357       {
101358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101359       };
101360     } catch (std::exception& e) {
101361       {
101362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101363       };
101364     } catch (...) {
101365       {
101366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101367       };
101368     }
101369   }
101370   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101371
101372   return jresult;
101373 }
101374
101375
101376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101377   void * jresult ;
101378   std::string *arg1 = 0 ;
101379   Dali::ImageDimensions arg2 ;
101380   Dali::FittingMode::Type arg3 ;
101381   Dali::ImageDimensions *argp2 ;
101382   Dali::Devel::PixelBuffer result;
101383
101384   if (!jarg1) {
101385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101386     return 0;
101387   }
101388   std::string arg1_str(jarg1);
101389   arg1 = &arg1_str;
101390   argp2 = (Dali::ImageDimensions *)jarg2;
101391   if (!argp2) {
101392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101393     return 0;
101394   }
101395   arg2 = *argp2;
101396   arg3 = (Dali::FittingMode::Type)jarg3;
101397   {
101398     try {
101399       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
101400     } catch (std::out_of_range& e) {
101401       {
101402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101403       };
101404     } catch (std::exception& e) {
101405       {
101406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101407       };
101408     } catch (...) {
101409       {
101410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101411       };
101412     }
101413   }
101414   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101415
101416   return jresult;
101417 }
101418
101419
101420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
101421   void * jresult ;
101422   std::string *arg1 = 0 ;
101423   Dali::ImageDimensions arg2 ;
101424   Dali::ImageDimensions *argp2 ;
101425   Dali::Devel::PixelBuffer result;
101426
101427   if (!jarg1) {
101428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101429     return 0;
101430   }
101431   std::string arg1_str(jarg1);
101432   arg1 = &arg1_str;
101433   argp2 = (Dali::ImageDimensions *)jarg2;
101434   if (!argp2) {
101435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101436     return 0;
101437   }
101438   arg2 = *argp2;
101439   {
101440     try {
101441       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
101442     } catch (std::out_of_range& e) {
101443       {
101444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101445       };
101446     } catch (std::exception& e) {
101447       {
101448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101449       };
101450     } catch (...) {
101451       {
101452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101453       };
101454     }
101455   }
101456   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101457
101458   return jresult;
101459 }
101460
101461
101462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
101463   void * jresult ;
101464   std::string *arg1 = 0 ;
101465   Dali::Devel::PixelBuffer result;
101466
101467   if (!jarg1) {
101468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101469     return 0;
101470   }
101471   std::string arg1_str(jarg1);
101472   arg1 = &arg1_str;
101473   {
101474     try {
101475       result = Dali::LoadImageFromFile((std::string const &)*arg1);
101476     } catch (std::out_of_range& e) {
101477       {
101478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101479       };
101480     } catch (std::exception& e) {
101481       {
101482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101483       };
101484     } catch (...) {
101485       {
101486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101487       };
101488     }
101489   }
101490   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101491
101492   return jresult;
101493 }
101494
101495
101496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101497   void * jresult ;
101498   std::string *arg1 = 0 ;
101499   Dali::ImageDimensions arg2 ;
101500   Dali::FittingMode::Type arg3 ;
101501   Dali::SamplingMode::Type arg4 ;
101502   bool arg5 ;
101503   Dali::ImageDimensions *argp2 ;
101504   Dali::ImageDimensions result;
101505
101506   if (!jarg1) {
101507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101508     return 0;
101509   }
101510   std::string arg1_str(jarg1);
101511   arg1 = &arg1_str;
101512   argp2 = (Dali::ImageDimensions *)jarg2;
101513   if (!argp2) {
101514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101515     return 0;
101516   }
101517   arg2 = *argp2;
101518   arg3 = (Dali::FittingMode::Type)jarg3;
101519   arg4 = (Dali::SamplingMode::Type)jarg4;
101520   arg5 = jarg5 ? true : false;
101521   {
101522     try {
101523       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101524     } catch (std::out_of_range& e) {
101525       {
101526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101527       };
101528     } catch (std::exception& e) {
101529       {
101530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101531       };
101532     } catch (...) {
101533       {
101534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101535       };
101536     }
101537   }
101538   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101539
101540   return jresult;
101541 }
101542
101543
101544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101545   void * jresult ;
101546   std::string *arg1 = 0 ;
101547   Dali::ImageDimensions arg2 ;
101548   Dali::FittingMode::Type arg3 ;
101549   Dali::SamplingMode::Type arg4 ;
101550   Dali::ImageDimensions *argp2 ;
101551   Dali::ImageDimensions result;
101552
101553   if (!jarg1) {
101554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101555     return 0;
101556   }
101557   std::string arg1_str(jarg1);
101558   arg1 = &arg1_str;
101559   argp2 = (Dali::ImageDimensions *)jarg2;
101560   if (!argp2) {
101561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101562     return 0;
101563   }
101564   arg2 = *argp2;
101565   arg3 = (Dali::FittingMode::Type)jarg3;
101566   arg4 = (Dali::SamplingMode::Type)jarg4;
101567   {
101568     try {
101569       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
101570     } catch (std::out_of_range& e) {
101571       {
101572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101573       };
101574     } catch (std::exception& e) {
101575       {
101576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101577       };
101578     } catch (...) {
101579       {
101580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101581       };
101582     }
101583   }
101584   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101585
101586   return jresult;
101587 }
101588
101589
101590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101591   void * jresult ;
101592   std::string *arg1 = 0 ;
101593   Dali::ImageDimensions arg2 ;
101594   Dali::FittingMode::Type arg3 ;
101595   Dali::ImageDimensions *argp2 ;
101596   Dali::ImageDimensions result;
101597
101598   if (!jarg1) {
101599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101600     return 0;
101601   }
101602   std::string arg1_str(jarg1);
101603   arg1 = &arg1_str;
101604   argp2 = (Dali::ImageDimensions *)jarg2;
101605   if (!argp2) {
101606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101607     return 0;
101608   }
101609   arg2 = *argp2;
101610   arg3 = (Dali::FittingMode::Type)jarg3;
101611   {
101612     try {
101613       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
101614     } catch (std::out_of_range& e) {
101615       {
101616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101617       };
101618     } catch (std::exception& e) {
101619       {
101620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101621       };
101622     } catch (...) {
101623       {
101624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101625       };
101626     }
101627   }
101628   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101629
101630   return jresult;
101631 }
101632
101633
101634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
101635   void * jresult ;
101636   std::string *arg1 = 0 ;
101637   Dali::ImageDimensions arg2 ;
101638   Dali::ImageDimensions *argp2 ;
101639   Dali::ImageDimensions result;
101640
101641   if (!jarg1) {
101642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101643     return 0;
101644   }
101645   std::string arg1_str(jarg1);
101646   arg1 = &arg1_str;
101647   argp2 = (Dali::ImageDimensions *)jarg2;
101648   if (!argp2) {
101649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101650     return 0;
101651   }
101652   arg2 = *argp2;
101653   {
101654     try {
101655       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
101656     } catch (std::out_of_range& e) {
101657       {
101658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101659       };
101660     } catch (std::exception& e) {
101661       {
101662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101663       };
101664     } catch (...) {
101665       {
101666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101667       };
101668     }
101669   }
101670   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101671
101672   return jresult;
101673 }
101674
101675
101676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
101677   void * jresult ;
101678   std::string *arg1 = 0 ;
101679   Dali::ImageDimensions result;
101680
101681   if (!jarg1) {
101682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101683     return 0;
101684   }
101685   std::string arg1_str(jarg1);
101686   arg1 = &arg1_str;
101687   {
101688     try {
101689       result = Dali::GetClosestImageSize((std::string const &)*arg1);
101690     } catch (std::out_of_range& e) {
101691       {
101692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101693       };
101694     } catch (std::exception& e) {
101695       {
101696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101697       };
101698     } catch (...) {
101699       {
101700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101701       };
101702     }
101703   }
101704   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101705
101706   return jresult;
101707 }
101708
101709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
101710   void * jresult ;
101711   std::string *arg1 = 0 ;
101712   Dali::ImageDimensions result;
101713
101714   if (!jarg1) {
101715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101716     return 0;
101717   }
101718   std::string arg1_str(jarg1);
101719   arg1 = &arg1_str;
101720   {
101721     try {
101722       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
101723     } catch (std::out_of_range& e) {
101724       {
101725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101726       };
101727     } catch (std::exception& e) {
101728       {
101729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101730       };
101731     } catch (...) {
101732       {
101733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101734       };
101735     }
101736   }
101737   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101738
101739   return jresult;
101740 }
101741
101742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101743   void * jresult ;
101744   std::string *arg1 = 0 ;
101745   Dali::ImageDimensions arg2 ;
101746   Dali::FittingMode::Type arg3 ;
101747   Dali::SamplingMode::Type arg4 ;
101748   bool arg5 ;
101749   Dali::ImageDimensions *argp2 ;
101750   Dali::Devel::PixelBuffer result;
101751
101752   if (!jarg1) {
101753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101754     return 0;
101755   }
101756   std::string arg1_str(jarg1);
101757   arg1 = &arg1_str;
101758   argp2 = (Dali::ImageDimensions *)jarg2;
101759   if (!argp2) {
101760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101761     return 0;
101762   }
101763   arg2 = *argp2;
101764   arg3 = (Dali::FittingMode::Type)jarg3;
101765   arg4 = (Dali::SamplingMode::Type)jarg4;
101766   arg5 = jarg5 ? true : false;
101767   {
101768     try {
101769       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101770     } catch (std::out_of_range& e) {
101771       {
101772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101773       };
101774     } catch (std::exception& e) {
101775       {
101776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101777       };
101778     } catch (...) {
101779       {
101780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101781       };
101782     }
101783   }
101784   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101785
101786   return jresult;
101787 }
101788
101789
101790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101791   void * jresult ;
101792   std::string *arg1 = 0 ;
101793   Dali::ImageDimensions arg2 ;
101794   Dali::FittingMode::Type arg3 ;
101795   Dali::SamplingMode::Type arg4 ;
101796   Dali::ImageDimensions *argp2 ;
101797   Dali::Devel::PixelBuffer result;
101798
101799   if (!jarg1) {
101800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101801     return 0;
101802   }
101803   std::string arg1_str(jarg1);
101804   arg1 = &arg1_str;
101805   argp2 = (Dali::ImageDimensions *)jarg2;
101806   if (!argp2) {
101807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101808     return 0;
101809   }
101810   arg2 = *argp2;
101811   arg3 = (Dali::FittingMode::Type)jarg3;
101812   arg4 = (Dali::SamplingMode::Type)jarg4;
101813   {
101814     try {
101815       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
101816     } catch (std::out_of_range& e) {
101817       {
101818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101819       };
101820     } catch (std::exception& e) {
101821       {
101822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101823       };
101824     } catch (...) {
101825       {
101826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101827       };
101828     }
101829   }
101830   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101831
101832   return jresult;
101833 }
101834
101835
101836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101837   void * jresult ;
101838   std::string *arg1 = 0 ;
101839   Dali::ImageDimensions arg2 ;
101840   Dali::FittingMode::Type arg3 ;
101841   Dali::ImageDimensions *argp2 ;
101842   Dali::Devel::PixelBuffer result;
101843
101844   if (!jarg1) {
101845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101846     return 0;
101847   }
101848   std::string arg1_str(jarg1);
101849   arg1 = &arg1_str;
101850   argp2 = (Dali::ImageDimensions *)jarg2;
101851   if (!argp2) {
101852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101853     return 0;
101854   }
101855   arg2 = *argp2;
101856   arg3 = (Dali::FittingMode::Type)jarg3;
101857   {
101858     try {
101859       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
101860     } catch (std::out_of_range& e) {
101861       {
101862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101863       };
101864     } catch (std::exception& e) {
101865       {
101866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101867       };
101868     } catch (...) {
101869       {
101870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101871       };
101872     }
101873   }
101874   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101875
101876   return jresult;
101877 }
101878
101879
101880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
101881   void * jresult ;
101882   std::string *arg1 = 0 ;
101883   Dali::ImageDimensions arg2 ;
101884   Dali::ImageDimensions *argp2 ;
101885   Dali::Devel::PixelBuffer result;
101886
101887   if (!jarg1) {
101888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101889     return 0;
101890   }
101891   std::string arg1_str(jarg1);
101892   arg1 = &arg1_str;
101893   argp2 = (Dali::ImageDimensions *)jarg2;
101894   if (!argp2) {
101895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101896     return 0;
101897   }
101898   arg2 = *argp2;
101899   {
101900     try {
101901       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
101902     } catch (std::out_of_range& e) {
101903       {
101904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101905       };
101906     } catch (std::exception& e) {
101907       {
101908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101909       };
101910     } catch (...) {
101911       {
101912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101913       };
101914     }
101915   }
101916   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101917
101918   return jresult;
101919 }
101920
101921
101922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
101923   void * jresult ;
101924   std::string *arg1 = 0 ;
101925   Dali::Devel::PixelBuffer result;
101926
101927   if (!jarg1) {
101928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101929     return 0;
101930   }
101931   std::string arg1_str(jarg1);
101932   arg1 = &arg1_str;
101933   {
101934     try {
101935       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
101936     } catch (std::out_of_range& e) {
101937       {
101938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101939       };
101940     } catch (std::exception& e) {
101941       {
101942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101943       };
101944     } catch (...) {
101945       {
101946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101947       };
101948     }
101949   }
101950   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101951
101952   return jresult;
101953 }
101954
101955
101956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
101957   void * jresult ;
101958   Dali::Toolkit::WebView result;
101959
101960   {
101961     try {
101962       result = Dali::Toolkit::WebView::New();
101963     } catch (std::out_of_range& e) {
101964       {
101965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101966       };
101967     } catch (std::exception& e) {
101968       {
101969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101970       };
101971     } catch (Dali::DaliException e) {
101972       {
101973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101974       };
101975     } catch (...) {
101976       {
101977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101978       };
101979     }
101980   }
101981   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
101982   return jresult;
101983 }
101984
101985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
101986   void * jresult ;
101987   Dali::Toolkit::WebView result;
101988
101989   std::string *arg1;
101990   std::string *arg2;
101991
101992   if (!jarg1) {
101993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
101994     return 0;
101995   }
101996   if (!jarg2) {
101997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
101998     return 0;
101999   }
102000
102001   std::string jarg1_str = std::string(jarg1);
102002   std::string jarg2_str = std::string(jarg2);
102003
102004   arg1 = &jarg1_str;
102005   arg2 = &jarg2_str;
102006
102007   {
102008     try {
102009       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
102010     } catch (std::out_of_range& e) {
102011       {
102012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102013       };
102014     } catch (std::exception& e) {
102015       {
102016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102017       };
102018     } catch (Dali::DaliException e) {
102019       {
102020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102021       };
102022     } catch (...) {
102023       {
102024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102025       };
102026     }
102027   }
102028   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102029   return jresult;
102030 }
102031
102032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
102033   void * jresult ;
102034   Dali::Toolkit::WebView *arg1 = 0 ;
102035   Dali::Toolkit::WebView *result = 0 ;
102036
102037   arg1 = (Dali::Toolkit::WebView *)jarg1;
102038   if (!arg1) {
102039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102040     return 0;
102041   }
102042   {
102043     try {
102044       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
102045     } catch (std::out_of_range& e) {
102046       {
102047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102048       };
102049     } catch (std::exception& e) {
102050       {
102051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102052       };
102053     } catch (Dali::DaliException e) {
102054       {
102055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102056       };
102057     } catch (...) {
102058       {
102059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102060       };
102061     }
102062   }
102063   jresult = (void *)result;
102064   return jresult;
102065 }
102066
102067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
102068   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102069   arg1 = (Dali::Toolkit::WebView *)jarg1;
102070   {
102071     try {
102072       delete arg1;
102073     } catch (std::out_of_range& e) {
102074       {
102075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102076       };
102077     } catch (std::exception& e) {
102078       {
102079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102080       };
102081     } catch (Dali::DaliException e) {
102082       {
102083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102084       };
102085     } catch (...) {
102086       {
102087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102088       };
102089     }
102090   }
102091 }
102092
102093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
102094   void * jresult ;
102095   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102096   Dali::Toolkit::WebView *arg2 = 0 ;
102097   Dali::Toolkit::WebView *result = 0 ;
102098
102099   arg1 = (Dali::Toolkit::WebView *)jarg1;
102100   arg2 = (Dali::Toolkit::WebView *)jarg2;
102101   if (!arg2) {
102102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102103     return 0;
102104   }
102105   {
102106     try {
102107       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
102108     } catch (std::out_of_range& e) {
102109       {
102110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102111       };
102112     } catch (std::exception& e) {
102113       {
102114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102115       };
102116     } catch (Dali::DaliException e) {
102117       {
102118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102119       };
102120     } catch (...) {
102121       {
102122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102123       };
102124     }
102125   }
102126   jresult = (void *)result;
102127   return jresult;
102128 }
102129
102130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
102131   void * jresult ;
102132   Dali::BaseHandle arg1 ;
102133   Dali::BaseHandle *argp1 ;
102134   Dali::Toolkit::WebView result;
102135
102136   argp1 = (Dali::BaseHandle *)jarg1;
102137   if (!argp1) {
102138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
102139     return 0;
102140   }
102141   arg1 = *argp1;
102142   {
102143     try {
102144       result = Dali::Toolkit::WebView::DownCast(arg1);
102145     } catch (std::out_of_range& e) {
102146       {
102147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102148       };
102149     } catch (std::exception& e) {
102150       {
102151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102152       };
102153     } catch (Dali::DaliException e) {
102154       {
102155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102156       };
102157     } catch (...) {
102158       {
102159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102160       };
102161     }
102162   }
102163   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102164   return jresult;
102165 }
102166
102167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
102168   return (int) Dali::Toolkit::WebView::Property::URL;
102169 }
102170
102171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
102172   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
102173 }
102174
102175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
102176   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
102177 }
102178
102179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
102180   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
102181 }
102182
102183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
102184   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
102185 }
102186
102187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
102188   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
102189 }
102190
102191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
102192   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
102193 }
102194
102195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
102196   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
102197 }
102198
102199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
102200   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102201   std::string *arg2;
102202
102203   arg1 = (Dali::Toolkit::WebView *)jarg1;
102204
102205   if (!jarg2) {
102206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102207     return;
102208   }
102209
102210   std::string jarg2str = std::string(jarg2);
102211   arg2 = &jarg2str;
102212   {
102213     try {
102214       (arg1)->LoadUrl((std::string const &)*arg2);
102215     } catch (std::out_of_range& e) {
102216       {
102217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102218       };
102219     } catch (std::exception& e) {
102220       {
102221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102222       };
102223     } catch (Dali::DaliException e) {
102224       {
102225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102226       };
102227     } catch (...) {
102228       {
102229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102230       };
102231     }
102232   }
102233 }
102234
102235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
102236   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102237   std::string *arg2;
102238
102239   arg1 = (Dali::Toolkit::WebView *)jarg1;
102240   if (!jarg2) {
102241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102242     return;
102243   }
102244   std::string jarg2str = std::string(jarg2);
102245   arg2 = &jarg2str;
102246   {
102247     try {
102248       (arg1)->LoadHTMLString((std::string const &)*arg2);
102249     } catch (std::out_of_range& e) {
102250       {
102251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102252       };
102253     } catch (std::exception& e) {
102254       {
102255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102256       };
102257     } catch (Dali::DaliException e) {
102258       {
102259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102260       };
102261     } catch (...) {
102262       {
102263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102264       };
102265     }
102266   }
102267 }
102268
102269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
102270   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102271
102272   arg1 = (Dali::Toolkit::WebView *)jarg1;
102273   {
102274     try {
102275       (arg1)->Reload();
102276     } catch (std::out_of_range& e) {
102277       {
102278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102279       };
102280     } catch (std::exception& e) {
102281       {
102282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102283       };
102284     } catch (Dali::DaliException e) {
102285       {
102286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102287       };
102288     } catch (...) {
102289       {
102290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102291       };
102292     }
102293   }
102294 }
102295
102296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
102297   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102298
102299   arg1 = (Dali::Toolkit::WebView *)jarg1;
102300   {
102301     try {
102302       (arg1)->StopLoading();
102303     } catch (std::out_of_range& e) {
102304       {
102305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102306       };
102307     } catch (std::exception& e) {
102308       {
102309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102310       };
102311     } catch (Dali::DaliException e) {
102312       {
102313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102314       };
102315     } catch (...) {
102316       {
102317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102318       };
102319     }
102320   }
102321 }
102322
102323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
102324   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102325
102326   arg1 = (Dali::Toolkit::WebView *)jarg1;
102327   {
102328     try {
102329       (arg1)->Suspend();
102330     } catch (std::out_of_range& e) {
102331       {
102332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102333       };
102334     } catch (std::exception& e) {
102335       {
102336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102337       };
102338     } catch (Dali::DaliException e) {
102339       {
102340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102341       };
102342     } catch (...) {
102343       {
102344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102345       };
102346     }
102347   }
102348 }
102349
102350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
102351   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102352
102353   arg1 = (Dali::Toolkit::WebView *)jarg1;
102354   {
102355     try {
102356       (arg1)->Resume();
102357     } catch (std::out_of_range& e) {
102358       {
102359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102360       };
102361     } catch (std::exception& e) {
102362       {
102363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102364       };
102365     } catch (Dali::DaliException e) {
102366       {
102367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102368       };
102369     } catch (...) {
102370       {
102371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102372       };
102373     }
102374   }
102375 }
102376
102377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
102378   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102379
102380   arg1 = (Dali::Toolkit::WebView *)jarg1;
102381   {
102382     try {
102383       (arg1)->GoBack();
102384     } catch (std::out_of_range& e) {
102385       {
102386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102387       };
102388     } catch (std::exception& e) {
102389       {
102390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102391       };
102392     } catch (Dali::DaliException e) {
102393       {
102394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102395       };
102396     } catch (...) {
102397       {
102398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102399       };
102400     }
102401   }
102402 }
102403
102404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
102405   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102406
102407   arg1 = (Dali::Toolkit::WebView *)jarg1;
102408   {
102409     try {
102410       (arg1)->GoForward();
102411     } catch (std::out_of_range& e) {
102412       {
102413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102414       };
102415     } catch (std::exception& e) {
102416       {
102417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102418       };
102419     } catch (Dali::DaliException e) {
102420       {
102421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102422       };
102423     } catch (...) {
102424       {
102425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102426       };
102427     }
102428   }
102429 }
102430
102431 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
102432   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102433   bool ret;
102434
102435   arg1 = (Dali::Toolkit::WebView *)jarg1;
102436   {
102437     try {
102438       ret = (arg1)->CanGoBack();
102439     } catch (std::out_of_range& e) {
102440       {
102441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
102442       };
102443     } catch (std::exception& e) {
102444       {
102445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
102446       };
102447     } catch (Dali::DaliException e) {
102448       {
102449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
102450       };
102451     } catch (...) {
102452       {
102453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
102454       };
102455     }
102456   }
102457   return ret;
102458 }
102459
102460 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
102461   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102462   bool ret;
102463
102464   arg1 = (Dali::Toolkit::WebView *)jarg1;
102465   {
102466     try {
102467       ret = (arg1)->CanGoForward();
102468     } catch (std::out_of_range& e) {
102469       {
102470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
102471       };
102472     } catch (std::exception& e) {
102473       {
102474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
102475       };
102476     } catch (Dali::DaliException e) {
102477       {
102478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
102479       };
102480     } catch (...) {
102481       {
102482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
102483       };
102484     }
102485   }
102486   return ret;
102487 }
102488
102489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
102490   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102491   std::string *arg2;
102492
102493   arg1 = (Dali::Toolkit::WebView *)jarg1;
102494   if (!jarg2) {
102495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102496     return;
102497   }
102498   std::string jarg2_str = std::string(jarg2);
102499   arg2 = &jarg2_str;
102500
102501   {
102502     try {
102503       if (jarg3) {
102504         void (*handler)(char*) = (void (*)(char*)) jarg3;
102505         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
102506           handler(SWIG_csharp_string_callback(result.c_str()));
102507         });
102508       } else {
102509         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
102510       }
102511     } catch (std::out_of_range& e) {
102512       {
102513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102514       };
102515     } catch (std::exception& e) {
102516       {
102517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102518       };
102519     } catch (Dali::DaliException e) {
102520       {
102521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102522       };
102523     } catch (...) {
102524       {
102525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102526       };
102527     }
102528   }
102529 }
102530
102531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
102532 {
102533   if (!jarg2) {
102534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102535     return;
102536   }
102537
102538   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102539   std::string exposedObjectName = jarg2;
102540   void (*handler)(char*) = (void (*)(char*)) jarg3;
102541
102542   {
102543     try {
102544       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
102545         handler(SWIG_csharp_string_callback(message.c_str()));
102546       });
102547     } catch (std::out_of_range& e) {
102548       {
102549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102550       };
102551     } catch (std::exception& e) {
102552       {
102553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102554       };
102555     } catch (Dali::DaliException e) {
102556       {
102557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102558       };
102559     } catch (...) {
102560       {
102561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102562       };
102563     }
102564   }
102565 }
102566
102567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
102568   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102569
102570   arg1 = (Dali::Toolkit::WebView *)jarg1;
102571   {
102572     try {
102573       (arg1)->ClearHistory();
102574     } catch (std::out_of_range& e) {
102575       {
102576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102577       };
102578     } catch (std::exception& e) {
102579       {
102580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102581       };
102582     } catch (Dali::DaliException e) {
102583       {
102584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102585       };
102586     } catch (...) {
102587       {
102588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102589       };
102590     }
102591   }
102592 }
102593
102594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
102595   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102596
102597   arg1 = (Dali::Toolkit::WebView *)jarg1;
102598   {
102599     try {
102600       (arg1)->ClearCache();
102601     } catch (std::out_of_range& e) {
102602       {
102603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102604       };
102605     } catch (std::exception& e) {
102606       {
102607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102608       };
102609     } catch (Dali::DaliException e) {
102610       {
102611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102612       };
102613     } catch (...) {
102614       {
102615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102616       };
102617     }
102618   }
102619 }
102620
102621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
102622   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102623
102624   arg1 = (Dali::Toolkit::WebView *)jarg1;
102625   {
102626     try {
102627       (arg1)->ClearCookies();
102628     } catch (std::out_of_range& e) {
102629       {
102630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102631       };
102632     } catch (std::exception& e) {
102633       {
102634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102635       };
102636     } catch (Dali::DaliException e) {
102637       {
102638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102639       };
102640     } catch (...) {
102641       {
102642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102643       };
102644     }
102645   }
102646 }
102647
102648 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
102649     return (Dali::Toolkit::Control *)jarg1;
102650 }
102651
102652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
102653   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102654   SignalConverter::WebViewPageLoadSignal* result = NULL;
102655   {
102656     try {
102657       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
102658     } catch (std::out_of_range& e) {
102659       {
102660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102661       };
102662     } catch (std::exception& e) {
102663       {
102664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102665       };
102666     } catch (Dali::DaliException e) {
102667       {
102668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102669       };
102670     } catch (...) {
102671       {
102672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102673       };
102674     }
102675   }
102676   return (void*) result;
102677 }
102678
102679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
102680   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102681   SignalConverter::WebViewPageLoadSignal* result = NULL;
102682   {
102683     try {
102684       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
102685     } catch (std::out_of_range& e) {
102686       {
102687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102688       };
102689     } catch (std::exception& e) {
102690       {
102691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102692       };
102693     } catch (Dali::DaliException e) {
102694       {
102695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102696       };
102697     } catch (...) {
102698       {
102699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102700       };
102701     }
102702   }
102703   return (void*) result;
102704 }
102705
102706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
102707 {
102708   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102709   {
102710     try {
102711       delete object;
102712     } catch (std::out_of_range& e) {
102713       {
102714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102715       };
102716     } catch (std::exception& e) {
102717       {
102718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102719       };
102720     } catch (Dali::DaliException e) {
102721       {
102722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102723       };
102724     } catch (...) {
102725       {
102726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102727       };
102728     }
102729   }
102730 }
102731
102732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
102733 {
102734   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102735   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102736   {
102737     try {
102738       proxy->Connect(callback);
102739     } catch (std::out_of_range& e) {
102740       {
102741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102742       };
102743     } catch (std::exception& e) {
102744       {
102745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102746       };
102747     } catch (Dali::DaliException e) {
102748       {
102749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102750       };
102751     } catch (...) {
102752       {
102753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102754       };
102755     }
102756   }
102757 }
102758
102759
102760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
102761   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102762   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102763   {
102764     try {
102765       proxy->Disconnect(callback);
102766     } catch (std::out_of_range& e) {
102767       {
102768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102769       };
102770     } catch (std::exception& e) {
102771       {
102772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102773       };
102774     } catch (Dali::DaliException e) {
102775       {
102776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102777       };
102778     } catch (...) {
102779       {
102780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102781       };
102782     }
102783   }
102784 }
102785
102786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
102787   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102788   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
102789   {
102790     try {
102791       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
102792     } catch (std::out_of_range& e) {
102793       {
102794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102795       };
102796     } catch (std::exception& e) {
102797       {
102798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102799       };
102800     } catch (Dali::DaliException e) {
102801       {
102802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102803       };
102804     } catch (...) {
102805       {
102806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102807       };
102808     }
102809   }
102810   return (void*) result;
102811 }
102812
102813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
102814 {
102815   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102816   {
102817     try {
102818       delete object;
102819     } catch (std::out_of_range& e) {
102820       {
102821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102822       };
102823     } catch (std::exception& e) {
102824       {
102825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102826       };
102827     } catch (Dali::DaliException e) {
102828       {
102829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102830       };
102831     } catch (...) {
102832       {
102833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102834       };
102835     }
102836   }
102837 }
102838
102839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
102840 {
102841   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102842   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
102843   {
102844     try {
102845       proxy->Connect(callback);
102846     } catch (std::out_of_range& e) {
102847       {
102848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102849       };
102850     } catch (std::exception& e) {
102851       {
102852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102853       };
102854     } catch (Dali::DaliException e) {
102855       {
102856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102857       };
102858     } catch (...) {
102859       {
102860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102861       };
102862     }
102863   }
102864 }
102865
102866
102867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
102868   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102869   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
102870   {
102871     try {
102872       proxy->Disconnect(callback);
102873     } catch (std::out_of_range& e) {
102874       {
102875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102876       };
102877     } catch (std::exception& e) {
102878       {
102879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102880       };
102881     } catch (Dali::DaliException e) {
102882       {
102883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102884       };
102885     } catch (...) {
102886       {
102887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102888       };
102889     }
102890   }
102891 }
102892
102893 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
102894   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
102895   char * jresult = SWIG_csharp_string_callback((const char *)result);
102896   return jresult;
102897 }
102898
102899 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
102900   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
102901   return result;
102902 }
102903
102904 #ifdef __cplusplus
102905 }
102906 #endif
102907