dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428 #include <dali/devel-api/events/key-event-devel.h>
 429
 430 #include <dali/public-api/math/matrix.h>
 431 #include <dali/public-api/math/matrix3.h>
 432 #include <dali/public-api/math/viewport.h>
 433 #include <dali/public-api/object/property-key.h>
 434 #include <dali/devel-api/object/csharp-type-info.h>
 435 #include <dali/devel-api/object/csharp-type-registry.h>
 436
 437 #include <dali/public-api/adaptor-framework/timer.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 440
 441 #include <dali/devel-api/images/nine-patch-image.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 456
 457 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 458 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 459 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 460
 461 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 463 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 464
 465 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 466 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 467 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 468
 469 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 470
 471 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 472 #include <dali/devel-api/adaptor-framework/image-loading.h>
 473
 474 #include <dali/public-api/events/mouse-button.h>
 475
 476 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 477 #include "web-view-signal-converter.h"
 478
 479 #include <dali/integration-api/debug.h>
 480
 481 // add here SWIG version check
 482
 483 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 484 // disable Swig-dependent warnings
 485
 486 // 'identifier1' has C-linkage specified,
 487 // but returns UDT 'identifier2' which is incompatible with C
 488 #pragma warning(disable: 4190)
 489
 490 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 491 #pragma warning(disable: 4800)
 492
 493 // debug info too long etc etc
 494 #pragma warning(disable: 4786)
 495 #endif
 496
 497
 498 #include <stdexcept>
 499
 500
 501 #include <string>
 502
 503
 504 #include <vector>
 505 #include <algorithm>
 506 #include <stdexcept>
 507
 508
 509 #include <map>
 510 #include <algorithm>
 511 #include <stdexcept>
 512
 513
 514 #include <utility>
 515
 516
 517 typedef float floatp;
 518
 519 SWIGINTERN floatp *new_floatp(){
 520   return new float();
 521 }
 522 SWIGINTERN void delete_floatp(floatp *self){
 523   if (self) delete self;
 524 }
 525 SWIGINTERN void floatp_assign(floatp *self,float value){
 526   *self = value;
 527 }
 528 SWIGINTERN float floatp_value(floatp *self){
 529   return *self;
 530 }
 531 SWIGINTERN float *floatp_cast(floatp *self){
 532   return self;
 533 }
 534 SWIGINTERN floatp *floatp_frompointer(float *t){
 535   return (floatp *) t;
 536 }
 537
 538 typedef int intp;
 539
 540 SWIGINTERN intp *new_intp(){
 541   return new int();
 542 }
 543 SWIGINTERN void delete_intp(intp *self){
 544   if (self) delete self;
 545 }
 546 SWIGINTERN void intp_assign(intp *self,int value){
 547   *self = value;
 548 }
 549 SWIGINTERN int intp_value(intp *self){
 550   return *self;
 551 }
 552 SWIGINTERN int *intp_cast(intp *self){
 553   return self;
 554 }
 555 SWIGINTERN intp *intp_frompointer(int *t){
 556   return (intp *) t;
 557 }
 558
 559 typedef double doublep;
 560
 561 SWIGINTERN doublep *new_doublep(){
 562   return new double();
 563 }
 564 SWIGINTERN void delete_doublep(doublep *self){
 565   if (self) delete self;
 566 }
 567 SWIGINTERN void doublep_assign(doublep *self,double value){
 568   *self = value;
 569 }
 570 SWIGINTERN double doublep_value(doublep *self){
 571   return *self;
 572 }
 573 SWIGINTERN double *doublep_cast(doublep *self){
 574   return self;
 575 }
 576 SWIGINTERN doublep *doublep_frompointer(double *t){
 577   return (doublep *) t;
 578 }
 579
 580 typedef unsigned int uintp;
 581
 582 SWIGINTERN uintp *new_uintp(){
 583   return new unsigned int();
 584 }
 585 SWIGINTERN void delete_uintp(uintp *self){
 586   if (self) delete self;
 587 }
 588 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 589   *self = value;
 590 }
 591 SWIGINTERN unsigned int uintp_value(uintp *self){
 592   return *self;
 593 }
 594 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 595   return self;
 596 }
 597 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 598   return (uintp *) t;
 599 }
 600
 601 typedef unsigned short ushortp;
 602
 603 SWIGINTERN ushortp *new_ushortp(){
 604   return new unsigned short();
 605 }
 606 SWIGINTERN void delete_ushortp(ushortp *self){
 607   if (self) delete self;
 608 }
 609 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 610   *self = value;
 611 }
 612 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 613   return *self;
 614 }
 615 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 616   return self;
 617 }
 618 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 619   return (ushortp *) t;
 620 }
 621
 622 unsigned int int_to_uint(int x) {
 623    return (unsigned int) x;
 624 }
 625
 626
 627 using namespace Dali;
 628 using namespace Dali::Toolkit;
 629
 630 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 631 {
 632   bool result = false;
 633   try
 634   {
 635     // C++ code. DALi uses Handle <-> Body design pattern.
 636     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 637     // Handles in DALi can be converted into a boolean type
 638     // to check if the handle has a valid body attached to it.
 639     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 640     if( *self )
 641     {
 642       result = true;
 643     }
 644     else
 645     {
 646       result = false;
 647     }
 648   }
 649   catch (std::out_of_range& e)
 650   {
 651     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 652     return 0;
 653   }
 654   catch (std::exception& e)
 655   {
 656     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 657     return 0;
 658   }
 659   catch (DaliException e)
 660   {
 661     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 662     return 0;
 663   }
 664   catch (...)
 665   {
 666     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 667     return 0;
 668   }
 669   return result;
 670 }
 671
 672 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 673 {
 674   bool result = false;
 675   try
 676   {
 677     // C++ code. Check if two handles reference the same implemtion
 678     if( *self == rhs)
 679     {
 680       result = true;
 681     }
 682     else
 683     {
 684       result = false;
 685     }
 686   }
 687   catch (std::out_of_range& e)
 688   {
 689     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 690     return 0;
 691   }
 692   catch (std::exception& e)
 693   {
 694     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 695     return 0;
 696   }
 697   catch (DaliException e)
 698   {
 699     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 700     return 0;
 701   }
 702   catch (...)
 703   {
 704     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 705     return 0;
 706   }
 707   return result;
 708 }
 709
 710
 711 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 712      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 713    }
 714 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 715      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 716    }
 717 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 718         std::vector< Dali::TouchPoint >* pv = 0;
 719         if (capacity >= 0) {
 720           pv = new std::vector< Dali::TouchPoint >();
 721           pv->reserve(capacity);
 722        } else {
 723           throw std::out_of_range("capacity");
 724        }
 725        return pv;
 726       }
 727 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 728         if (index>=0 && index<(int)self->size())
 729           return (*self)[index];
 730         else
 731           throw std::out_of_range("index");
 732       }
 733 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 734         if (index>=0 && index<(int)self->size())
 735           return (*self)[index];
 736         else
 737           throw std::out_of_range("index");
 738       }
 739 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 740         if (index>=0 && index<(int)self->size())
 741           (*self)[index] = val;
 742         else
 743           throw std::out_of_range("index");
 744       }
 745 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 746         self->insert(self->end(), values.begin(), values.end());
 747       }
 748 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 749         if (index < 0)
 750           throw std::out_of_range("index");
 751         if (count < 0)
 752           throw std::out_of_range("count");
 753         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 754           throw std::invalid_argument("invalid range");
 755         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 756       }
 757 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 758         if (index>=0 && index<(int)self->size()+1)
 759           self->insert(self->begin()+index, x);
 760         else
 761           throw std::out_of_range("index");
 762       }
 763 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 764         if (index>=0 && index<(int)self->size()+1)
 765           self->insert(self->begin()+index, values.begin(), values.end());
 766         else
 767           throw std::out_of_range("index");
 768       }
 769 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 770         if (index>=0 && index<(int)self->size())
 771           self->erase(self->begin() + index);
 772         else
 773           throw std::out_of_range("index");
 774       }
 775 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 776         if (index < 0)
 777           throw std::out_of_range("index");
 778         if (count < 0)
 779           throw std::out_of_range("count");
 780         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 781           throw std::invalid_argument("invalid range");
 782         self->erase(self->begin()+index, self->begin()+index+count);
 783       }
 784 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 785         if (count < 0)
 786           throw std::out_of_range("count");
 787         return new std::vector< Dali::TouchPoint >(count, value);
 788       }
 789 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 790         std::reverse(self->begin(), self->end());
 791       }
 792 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 793         if (index < 0)
 794           throw std::out_of_range("index");
 795         if (count < 0)
 796           throw std::out_of_range("count");
 797         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 798           throw std::invalid_argument("invalid range");
 799         std::reverse(self->begin()+index, self->begin()+index+count);
 800       }
 801 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 802         if (index < 0)
 803           throw std::out_of_range("index");
 804         if (index+values.size() > self->size())
 805           throw std::out_of_range("index");
 806         std::copy(values.begin(), values.end(), self->begin()+index);
 807       }
 808 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 809          return self->Empty();
 810       }
 811 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 812         return self->GetConnectionCount();
 813       }
 814 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 815           self->Connect( func );
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 818           self->Disconnect( func );
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 821           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 822 /*@SWIG@*/ self->Emit( arg );
 823       }
 824 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 825          return self->Empty();
 826       }
 827 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 828         return self->GetConnectionCount();
 829       }
 830 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 831           self->Connect( func );
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 834           self->Disconnect( func );
 835       }
 836 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 837           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 838 /*@SWIG@*/ self->Emit( arg );
 839       }
 840 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 841          return self->Empty();
 842       }
 843 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 844         return self->GetConnectionCount();
 845       }
 846 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 847           self->Connect( func );
 848       }
 849 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 850           self->Disconnect( func );
 851       }
 852 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 853           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 854 /*@SWIG@*/ self->Emit( arg );
 855       }
 856 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 857          return self->Empty();
 858       }
 859 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 860         return self->GetConnectionCount();
 861       }
 862 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 863           self->Connect( func );
 864       }
 865 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 866           self->Disconnect( func );
 867       }
 868 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 869           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 870 /*@SWIG@*/ self->Emit( arg );
 871       }
 872 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 873          return self->Empty();
 874       }
 875 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 876         return self->GetConnectionCount();
 877       }
 878 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 879           self->Connect( func );
 880       }
 881 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 882           self->Disconnect( func );
 883       }
 884 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 885           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 886 /*@SWIG@*/ self->Emit( arg );
 887       }
 888 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 889          return self->Empty();
 890       }
 891 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 892         return self->GetConnectionCount();
 893       }
 894 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 895         self->Connect( func );
 896       }
 897 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 898         self->Disconnect( func );
 899       }
 900 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 901         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 902 /*@SWIG@*/ self->Emit( arg1, arg2 );
 903       }
 904 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 905          return self->Empty();
 906       }
 907 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 908         return self->GetConnectionCount();
 909       }
 910 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 911         self->Connect( func );
 912       }
 913 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 914         self->Disconnect( func );
 915       }
 916 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 917         return self->Emit( arg1, arg2 );
 918       }
 919 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 920          return self->Empty();
 921       }
 922 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 923         return self->GetConnectionCount();
 924       }
 925 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 926         self->Connect( func );
 927       }
 928 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 929         self->Disconnect( func );
 930       }
 931 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 932         return self->Emit( arg1, arg2 );
 933       }
 934 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 935          return self->Empty();
 936       }
 937 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 938         return self->GetConnectionCount();
 939       }
 940 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 941         self->Connect( func );
 942       }
 943 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 944         self->Disconnect( func );
 945       }
 946 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 947         return self->Emit( arg1, arg2 );
 948       }
 949 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 950          return self->Empty();
 951       }
 952 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 953         return self->GetConnectionCount();
 954       }
 955 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 956           self->Connect( func );
 957       }
 958 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 959           self->Disconnect( func );
 960       }
 961 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 962           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 963 /*@SWIG@*/ self->Emit( arg );
 964       }
 965 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 966          return self->Empty();
 967       }
 968 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 969         return self->GetConnectionCount();
 970       }
 971 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 972           self->Connect( func );
 973       }
 974 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 975           self->Disconnect( func );
 976       }
 977 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 978           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 979 /*@SWIG@*/ self->Emit( arg );
 980       }
 981 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 982          return self->Empty();
 983       }
 984 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 985         return self->GetConnectionCount();
 986       }
 987 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 988           self->Connect( func );
 989       }
 990 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 991           self->Disconnect( func );
 992       }
 993 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 994           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 995 /*@SWIG@*/ self->Emit( arg );
 996       }
 997 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 998          return self->Empty();
 999       }
1000 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
1001         return self->GetConnectionCount();
1002       }
1003 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1004           self->Connect( func );
1005       }
1006 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1007           self->Disconnect( func );
1008       }
1009 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
1010           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1011 /*@SWIG@*/ self->Emit( arg );
1012       }
1013 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1014          return self->Empty();
1015       }
1016 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1017         return self->GetConnectionCount();
1018       }
1019 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1020         self->Connect( func );
1021       }
1022 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1023         self->Disconnect( func );
1024       }
1025 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
1026         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1027 /*@SWIG@*/ self->Emit( arg1, arg2 );
1028       }
1029 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1030          return self->Empty();
1031       }
1032 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1033         return self->GetConnectionCount();
1034       }
1035 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1036         self->Connect( func );
1037       }
1038 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1039         self->Disconnect( func );
1040       }
1041 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
1042         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1043 /*@SWIG@*/ self->Emit( arg1, arg2 );
1044       }
1045 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1046          return self->Empty();
1047       }
1048 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1049         return self->GetConnectionCount();
1050       }
1051 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1052         self->Connect( func );
1053       }
1054 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1055         self->Disconnect( func );
1056       }
1057 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
1058         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1059 /*@SWIG@*/ self->Emit( arg1, arg2 );
1060       }
1061 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1062          return self->Empty();
1063       }
1064 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1065         return self->GetConnectionCount();
1066       }
1067 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1068           self->Connect( func );
1069       }
1070 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1071           self->Disconnect( func );
1072       }
1073 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1074           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1075 /*@SWIG@*/ self->Emit( arg );
1076       }
1077 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1078          return self->Empty();
1079       }
1080 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1081         return self->GetConnectionCount();
1082       }
1083 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1084           return self->Connect( func );
1085       }
1086 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1087           self->Disconnect( func );
1088       }
1089 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
1090           self->Emit( arg1, arg3 );
1091       }
1092 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1093          return self->Empty();
1094       }
1095 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1096         return self->GetConnectionCount();
1097       }
1098 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1099           return self->Connect( func );
1100       }
1101 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1102           self->Disconnect( func );
1103       }
1104 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1105           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1106 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1107       }
1108
1109 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1110          return self->Empty();
1111       }
1112 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1113         return self->GetConnectionCount();
1114       }
1115 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1116           self->Connect( func );
1117       }
1118 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1119           self->Disconnect( func );
1120       }
1121 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1122           return self->Emit();
1123       }
1124
1125 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1126         std::vector< unsigned int >* pv = 0;
1127         if (capacity >= 0) {
1128           pv = new std::vector< unsigned int >();
1129           pv->reserve(capacity);
1130        } else {
1131           throw std::out_of_range("capacity");
1132        }
1133        return pv;
1134       }
1135 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1136         if (index>=0 && index<(int)self->size())
1137           return (*self)[index];
1138         else
1139           throw std::out_of_range("index");
1140       }
1141 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1142         if (index>=0 && index<(int)self->size())
1143           return (*self)[index];
1144         else
1145           throw std::out_of_range("index");
1146       }
1147 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1148         if (index>=0 && index<(int)self->size())
1149           (*self)[index] = val;
1150         else
1151           throw std::out_of_range("index");
1152       }
1153 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1154         self->insert(self->end(), values.begin(), values.end());
1155       }
1156 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1157         if (index < 0)
1158           throw std::out_of_range("index");
1159         if (count < 0)
1160           throw std::out_of_range("count");
1161         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1162           throw std::invalid_argument("invalid range");
1163         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1164       }
1165 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1166         if (index>=0 && index<(int)self->size()+1)
1167           self->insert(self->begin()+index, x);
1168         else
1169           throw std::out_of_range("index");
1170       }
1171 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1172         if (index>=0 && index<(int)self->size()+1)
1173           self->insert(self->begin()+index, values.begin(), values.end());
1174         else
1175           throw std::out_of_range("index");
1176       }
1177 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1178         if (index>=0 && index<(int)self->size())
1179           self->erase(self->begin() + index);
1180         else
1181           throw std::out_of_range("index");
1182       }
1183 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1184         if (index < 0)
1185           throw std::out_of_range("index");
1186         if (count < 0)
1187           throw std::out_of_range("count");
1188         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1189           throw std::invalid_argument("invalid range");
1190         self->erase(self->begin()+index, self->begin()+index+count);
1191       }
1192 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1193         if (count < 0)
1194           throw std::out_of_range("count");
1195         return new std::vector< unsigned int >(count, value);
1196       }
1197 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1198         std::reverse(self->begin(), self->end());
1199       }
1200 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1201         if (index < 0)
1202           throw std::out_of_range("index");
1203         if (count < 0)
1204           throw std::out_of_range("count");
1205         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1206           throw std::invalid_argument("invalid range");
1207         std::reverse(self->begin()+index, self->begin()+index+count);
1208       }
1209 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1210         if (index < 0)
1211           throw std::out_of_range("index");
1212         if (index+values.size() > self->size())
1213           throw std::out_of_range("index");
1214         std::copy(values.begin(), values.end(), self->begin()+index);
1215       }
1216 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1217         return std::find(self->begin(), self->end(), value) != self->end();
1218       }
1219 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1220         int index = -1;
1221         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1222         if (it != self->end())
1223           index = (int)(it - self->begin());
1224         return index;
1225       }
1226 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1227         int index = -1;
1228         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1229         if (rit != self->rend())
1230           index = (int)(self->rend() - 1 - rit);
1231         return index;
1232       }
1233 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1234         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1235         if (it != self->end()) {
1236           self->erase(it);
1237           return true;
1238         }
1239         return false;
1240       }
1241 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1242         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1243         if (capacity >= 0) {
1244           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1245           pv->reserve(capacity);
1246        } else {
1247           throw std::out_of_range("capacity");
1248        }
1249        return pv;
1250       }
1251 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1252         if (index>=0 && index<(int)self->size())
1253           return (*self)[index];
1254         else
1255           throw std::out_of_range("index");
1256       }
1257 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1258         if (index>=0 && index<(int)self->size())
1259           return (*self)[index];
1260         else
1261           throw std::out_of_range("index");
1262       }
1263 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1264         if (index>=0 && index<(int)self->size())
1265           (*self)[index] = val;
1266         else
1267           throw std::out_of_range("index");
1268       }
1269 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1270         self->insert(self->end(), values.begin(), values.end());
1271       }
1272 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1273         if (index < 0)
1274           throw std::out_of_range("index");
1275         if (count < 0)
1276           throw std::out_of_range("count");
1277         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1278           throw std::invalid_argument("invalid range");
1279         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1280       }
1281 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1282         if (index>=0 && index<(int)self->size()+1)
1283           self->insert(self->begin()+index, x);
1284         else
1285           throw std::out_of_range("index");
1286       }
1287 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1288         if (index>=0 && index<(int)self->size()+1)
1289           self->insert(self->begin()+index, values.begin(), values.end());
1290         else
1291           throw std::out_of_range("index");
1292       }
1293 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1294         if (index>=0 && index<(int)self->size())
1295           self->erase(self->begin() + index);
1296         else
1297           throw std::out_of_range("index");
1298       }
1299 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1300         if (index < 0)
1301           throw std::out_of_range("index");
1302         if (count < 0)
1303           throw std::out_of_range("count");
1304         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1305           throw std::invalid_argument("invalid range");
1306         self->erase(self->begin()+index, self->begin()+index+count);
1307       }
1308 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1309         if (count < 0)
1310           throw std::out_of_range("count");
1311         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1312       }
1313 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1314         std::reverse(self->begin(), self->end());
1315       }
1316 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1317         if (index < 0)
1318           throw std::out_of_range("index");
1319         if (count < 0)
1320           throw std::out_of_range("count");
1321         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1322           throw std::invalid_argument("invalid range");
1323         std::reverse(self->begin()+index, self->begin()+index+count);
1324       }
1325 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1326         if (index < 0)
1327           throw std::out_of_range("index");
1328         if (index+values.size() > self->size())
1329           throw std::out_of_range("index");
1330         std::copy(values.begin(), values.end(), self->begin()+index);
1331       }
1332 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1333         std::vector< Dali::Actor >* pv = 0;
1334         if (capacity >= 0) {
1335           pv = new std::vector< Dali::Actor >();
1336           pv->reserve(capacity);
1337        } else {
1338           throw std::out_of_range("capacity");
1339        }
1340        return pv;
1341       }
1342 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1343         if (index>=0 && index<(int)self->size())
1344           return (*self)[index];
1345         else
1346           throw std::out_of_range("index");
1347       }
1348 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1349         if (index>=0 && index<(int)self->size())
1350           return (*self)[index];
1351         else
1352           throw std::out_of_range("index");
1353       }
1354 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1355         if (index>=0 && index<(int)self->size())
1356           (*self)[index] = val;
1357         else
1358           throw std::out_of_range("index");
1359       }
1360 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1361         self->insert(self->end(), values.begin(), values.end());
1362       }
1363 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1364         if (index < 0)
1365           throw std::out_of_range("index");
1366         if (count < 0)
1367           throw std::out_of_range("count");
1368         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1369           throw std::invalid_argument("invalid range");
1370         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1371       }
1372 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1373         if (index>=0 && index<(int)self->size()+1)
1374           self->insert(self->begin()+index, x);
1375         else
1376           throw std::out_of_range("index");
1377       }
1378 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1379         if (index>=0 && index<(int)self->size()+1)
1380           self->insert(self->begin()+index, values.begin(), values.end());
1381         else
1382           throw std::out_of_range("index");
1383       }
1384 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1385         if (index>=0 && index<(int)self->size())
1386           self->erase(self->begin() + index);
1387         else
1388           throw std::out_of_range("index");
1389       }
1390 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1391         if (index < 0)
1392           throw std::out_of_range("index");
1393         if (count < 0)
1394           throw std::out_of_range("count");
1395         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1396           throw std::invalid_argument("invalid range");
1397         self->erase(self->begin()+index, self->begin()+index+count);
1398       }
1399 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1400         if (count < 0)
1401           throw std::out_of_range("count");
1402         return new std::vector< Dali::Actor >(count, value);
1403       }
1404 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1405         std::reverse(self->begin(), self->end());
1406       }
1407 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1408         if (index < 0)
1409           throw std::out_of_range("index");
1410         if (count < 0)
1411           throw std::out_of_range("count");
1412         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1413           throw std::invalid_argument("invalid range");
1414         std::reverse(self->begin()+index, self->begin()+index+count);
1415       }
1416 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1417         if (index < 0)
1418           throw std::out_of_range("index");
1419         if (index+values.size() > self->size())
1420           throw std::out_of_range("index");
1421         std::copy(values.begin(), values.end(), self->begin()+index);
1422       }
1423 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1424          return self->Empty();
1425       }
1426 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1427         return self->GetConnectionCount();
1428       }
1429 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1430           self->Connect( func );
1431       }
1432 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1433           self->Disconnect( func );
1434       }
1435 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1436           return self->Emit( arg );
1437       }
1438 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1439          return self->Empty();
1440       }
1441 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1442         return self->GetConnectionCount();
1443       }
1444 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1445         self->Connect( func );
1446       }
1447 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1448         self->Disconnect( func );
1449       }
1450 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1451         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1452 /*@SWIG@*/ self->Emit( arg1, arg2 );
1453       }
1454 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1455          return self->Empty();
1456       }
1457 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1458         return self->GetConnectionCount();
1459       }
1460 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1461         self->Connect( func );
1462       }
1463 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1464         self->Disconnect( func );
1465       }
1466 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1467         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1468 /*@SWIG@*/ self->Emit( arg1, arg2 );
1469       }
1470 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1471          return self->Empty();
1472       }
1473 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1474         return self->GetConnectionCount();
1475       }
1476 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1477         self->Connect( func );
1478       }
1479 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1480         self->Disconnect( func );
1481       }
1482 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1483         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1484 /*@SWIG@*/ self->Emit( arg1, arg2 );
1485       }
1486 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1487          return self->Empty();
1488       }
1489 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1490         return self->GetConnectionCount();
1491       }
1492 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1493         self->Connect( func );
1494       }
1495 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1496         self->Disconnect( func );
1497       }
1498 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1499         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1500 /*@SWIG@*/ self->Emit( arg1, arg2 );
1501       }
1502 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1503          return self->Empty();
1504       }
1505 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1506         return self->GetConnectionCount();
1507       }
1508 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1509           self->Connect( func );
1510       }
1511 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1512           self->Disconnect( func );
1513       }
1514 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1515           return self->Emit( arg );
1516       }
1517 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1518          return self->Empty();
1519       }
1520 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1521         return self->GetConnectionCount();
1522       }
1523 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1524           self->Connect( func );
1525       }
1526 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1527           self->Disconnect( func );
1528       }
1529 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1530           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1531 /*@SWIG@*/ self->Emit( arg );
1532       }
1533 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1534          return self->Empty();
1535       }
1536 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1537         return self->GetConnectionCount();
1538       }
1539 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1540           return self->Connect( func );
1541       }
1542 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1543           self->Disconnect( func );
1544       }
1545 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1546           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1547 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1548       }
1549 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1550          return self->Empty();
1551       }
1552 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1553         return self->GetConnectionCount();
1554       }
1555 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1556           self->Connect( func );
1557       }
1558 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1559           self->Disconnect( func );
1560       }
1561 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1562           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1563 /*@SWIG@*/ self->Emit( arg );
1564       }
1565 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1566          return self->Empty();
1567       }
1568 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1569         return self->GetConnectionCount();
1570       }
1571 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1572           return self->Connect( func );
1573       }
1574 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1575           self->Disconnect( func );
1576       }
1577 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1578           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1579 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1580       }
1581 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1582          return self->Empty();
1583       }
1584 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1585         return self->GetConnectionCount();
1586       }
1587 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1588           self->Connect( func );
1589       }
1590 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1591           self->Disconnect( func );
1592       }
1593 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1594           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1595 /*@SWIG@*/ self->Emit( arg );
1596       }
1597 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1598          return self->Empty();
1599       }
1600 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1601         return self->GetConnectionCount();
1602       }
1603 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1604           self->Connect( func );
1605       }
1606 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1607           self->Disconnect( func );
1608       }
1609 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1610           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1611 /*@SWIG@*/ self->Emit( arg );
1612       }
1613
1614
1615 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1616          return self->Empty();
1617       }
1618 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1619         return self->GetConnectionCount();
1620       }
1621 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1622         self->Connect( func );
1623       }
1624 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1625         self->Disconnect( func );
1626       }
1627 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1628         return self->Emit( arg1, arg2 );
1629       }
1630 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1631          return self->Empty();
1632       }
1633 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1634         return self->GetConnectionCount();
1635       }
1636 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1637           self->Connect( func );
1638       }
1639 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1640           self->Disconnect( func );
1641       }
1642 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1643           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1644 /*@SWIG@*/ self->Emit( arg );
1645       }
1646 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1647          return self->Empty();
1648       }
1649 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1650         return self->GetConnectionCount();
1651       }
1652 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1653           self->Connect( func );
1654       }
1655 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1656           self->Disconnect( func );
1657       }
1658 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1659           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1660 /*@SWIG@*/ self->Emit( arg );
1661       }
1662 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1663          return self->Empty();
1664       }
1665 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1666         return self->GetConnectionCount();
1667       }
1668 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1669         self->Connect( func );
1670       }
1671 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1672         self->Disconnect( func );
1673       }
1674 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1675         return self->Emit( arg1, arg2 );
1676       }
1677 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1678          return self->Empty();
1679       }
1680 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1681         return self->GetConnectionCount();
1682       }
1683 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1684         self->Connect( func );
1685       }
1686 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1687         self->Disconnect( func );
1688       }
1689 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1690         return self->Emit( arg1, arg2 );
1691       }
1692
1693 /* ---------------------------------------------------
1694  * C++ director class methods
1695  * --------------------------------------------------- */
1696
1697 #include "dali_wrap.h"
1698
1699 /*
1700  *  Widget director
1701  */
1702 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1703   swig_init_callbacks();
1704 }
1705
1706 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1707 }
1708
1709 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1710   char * jcontentInfo = 0 ;
1711   void * jwindow  ;
1712
1713   if (!swig_callbackOnCreate) {
1714     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1715     return;
1716   } else {
1717     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1718     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1719     swig_callbackOnCreate(jcontentInfo, jwindow);
1720   }
1721 }
1722
1723 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1724   char * jcontentInfo = 0 ;
1725   int jtype  ;
1726
1727   if (!swig_callbackOnTerminate) {
1728     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1729     return;
1730   } else {
1731     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1732     jtype = (int)type;
1733     swig_callbackOnTerminate(jcontentInfo, jtype);
1734   }
1735 }
1736
1737 void SwigDirector_WidgetImpl::OnPause() {
1738   if (!swig_callbackOnPause) {
1739     Dali::Internal::Adaptor::Widget::OnPause();
1740     return;
1741   } else {
1742     swig_callbackOnPause();
1743   }
1744 }
1745
1746 void SwigDirector_WidgetImpl::OnResume() {
1747   if (!swig_callbackOnResume) {
1748     Dali::Internal::Adaptor::Widget::OnResume();
1749     return;
1750   } else {
1751     swig_callbackOnResume();
1752   }
1753 }
1754
1755 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1756   void * jwindow  ;
1757
1758   if (!swig_callbackOnResize) {
1759     Dali::Internal::Adaptor::Widget::OnResize(window);
1760     return;
1761   } else {
1762     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1763     swig_callbackOnResize(jwindow);
1764   }
1765 }
1766
1767 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1768   char * jcontentInfo = 0 ;
1769   int jforce  ;
1770
1771   if (!swig_callbackOnUpdate) {
1772     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1773     return;
1774   } else {
1775     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1776     jforce = force;
1777     swig_callbackOnUpdate(jcontentInfo, jforce);
1778   }
1779 }
1780
1781 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1782   void * jslotObserver = 0 ;
1783   void * jcallback = 0 ;
1784
1785   if (!swig_callbackSignalConnected) {
1786     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1787     return;
1788   } else {
1789     jslotObserver = (void *) slotObserver;
1790     jcallback = (void *) callback;
1791     swig_callbackSignalConnected(jslotObserver, jcallback);
1792   }
1793 }
1794
1795 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1796   void * jslotObserver = 0 ;
1797   void * jcallback = 0 ;
1798
1799   if (!swig_callbackSignalDisconnected) {
1800     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1801     return;
1802   } else {
1803     jslotObserver = (void *) slotObserver;
1804     jcallback = (void *) callback;
1805     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1806   }
1807 }
1808
1809 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1810
1811   swig_callbackOnCreate = callbackOnCreate;
1812   swig_callbackOnTerminate = callbackOnTerminate;
1813   swig_callbackOnPause = callbackOnPause;
1814   swig_callbackOnResume = callbackOnResume;
1815   swig_callbackOnResize = callbackOnResize;
1816   swig_callbackOnUpdate = callbackOnUpdate;
1817   swig_callbackSignalConnected = callbackSignalConnected;
1818   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1819 }
1820
1821 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1822   swig_callbackOnCreate = 0;
1823   swig_callbackOnTerminate = 0;
1824   swig_callbackOnPause = 0;
1825   swig_callbackOnResume = 0;
1826   swig_callbackOnResize = 0;
1827   swig_callbackOnUpdate = 0;
1828   swig_callbackSignalConnected = 0;
1829   swig_callbackSignalDisconnected = 0;
1830 }
1831
1832
1833 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1834   swig_init_callbacks();
1835 }
1836
1837 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1838
1839 }
1840
1841
1842 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1843   int jdepth  ;
1844
1845   if (!swig_callbackOnStageConnection) {
1846     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1847     return;
1848   } else {
1849     jdepth = depth;
1850     swig_callbackOnStageConnection(jdepth);
1851   }
1852 }
1853
1854 void SwigDirector_ViewImpl::OnStageDisconnection() {
1855   if (!swig_callbackOnStageDisconnection) {
1856     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1857     return;
1858   } else {
1859     swig_callbackOnStageDisconnection();
1860   }
1861 }
1862
1863 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1864   void * jchild = 0 ;
1865
1866   if (!swig_callbackOnChildAdd) {
1867     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1868     return;
1869   } else {
1870     jchild = (Dali::Actor *) &child;
1871     swig_callbackOnChildAdd(jchild);
1872   }
1873 }
1874
1875 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1876   void * jchild = 0 ;
1877
1878   if (!swig_callbackOnChildRemove) {
1879     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1880     return;
1881   } else {
1882     jchild = (Dali::Actor *) &child;
1883     swig_callbackOnChildRemove(jchild);
1884   }
1885 }
1886
1887 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1888   int jindex  ;
1889   void * jpropertyValue  ;
1890
1891   if (!swig_callbackOnPropertySet) {
1892     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1893     return;
1894   } else {
1895     jindex = index;
1896     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1897     swig_callbackOnPropertySet(jindex, jpropertyValue);
1898   }
1899 }
1900
1901 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1902   void * jtargetSize = 0 ;
1903
1904   if (!swig_callbackOnSizeSet) {
1905     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1906     return;
1907   } else {
1908     jtargetSize = (Dali::Vector3 *) &targetSize;
1909     swig_callbackOnSizeSet(jtargetSize);
1910   }
1911 }
1912
1913 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1914   void * janimation = 0 ;
1915   void * jtargetSize = 0 ;
1916
1917   if (!swig_callbackOnSizeAnimation) {
1918     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1919     return;
1920   } else {
1921     janimation = (Dali::Animation *) &animation;
1922     jtargetSize = (Dali::Vector3 *) &targetSize;
1923     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1924   }
1925 }
1926
1927 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1928   bool c_result = SwigValueInit< bool >() ;
1929   unsigned int jresult = 0 ;
1930   void * jarg0 = 0 ;
1931
1932   if (!swig_callbackOnTouchEvent) {
1933     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1934   } else {
1935     jarg0 = (Dali::TouchEvent *) &event;
1936     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1937     c_result = jresult ? true : false;
1938   }
1939   return c_result;
1940 }
1941
1942 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1943   bool c_result = SwigValueInit< bool >() ;
1944   unsigned int jresult = 0 ;
1945   void * jarg0 = 0 ;
1946
1947   if (!swig_callbackOnHoverEvent) {
1948     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1949   } else {
1950     jarg0 = (Dali::HoverEvent *) &event;
1951     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1952     c_result = jresult ? true : false;
1953   }
1954   return c_result;
1955 }
1956
1957 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1958   bool c_result = SwigValueInit< bool >() ;
1959   unsigned int jresult = 0 ;
1960   void * jarg0 = 0 ;
1961
1962   if (!swig_callbackOnKeyEvent) {
1963     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1964   } else {
1965     jarg0 = (Dali::KeyEvent *) &event;
1966     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1967     c_result = jresult ? true : false;
1968   }
1969   return c_result;
1970 }
1971
1972 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1973   bool c_result = SwigValueInit< bool >() ;
1974   unsigned int jresult = 0 ;
1975   void * jarg0 = 0 ;
1976
1977   if (!swig_callbackOnWheelEvent) {
1978     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1979   } else {
1980     jarg0 = (Dali::WheelEvent *) &event;
1981     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1982     c_result = jresult ? true : false;
1983   }
1984   return c_result;
1985 }
1986
1987 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1988   void * jsize = 0 ;
1989   void * jcontainer = 0 ;
1990
1991   if (!swig_callbackOnRelayout) {
1992     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1993     return;
1994   } else {
1995     jsize = (Dali::Vector2 *) &size;
1996     jcontainer = (Dali::RelayoutContainer *) &container;
1997     swig_callbackOnRelayout(jsize, jcontainer);
1998   }
1999 }
2000
2001 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
2002   int jpolicy  ;
2003   int jdimension  ;
2004
2005   if (!swig_callbackOnSetResizePolicy) {
2006     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2007     return;
2008   } else {
2009     jpolicy = (int)policy;
2010     jdimension = (int)dimension;
2011     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2012   }
2013 }
2014
2015 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2016   Dali::Vector3 c_result ;
2017   void * jresult = 0 ;
2018
2019   if (!swig_callbackGetNaturalSize) {
2020     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2021   } else {
2022     jresult = (void *) swig_callbackGetNaturalSize();
2023     if (!jresult) {
2024       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2025       return c_result;
2026     }
2027     c_result = *(Dali::Vector3 *)jresult;
2028   }
2029   return c_result;
2030 }
2031
2032 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2033   float c_result = SwigValueInit< float >() ;
2034   float jresult = 0 ;
2035   void * jchild = 0 ;
2036   int jdimension  ;
2037
2038   if (!swig_callbackCalculateChildSize) {
2039     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2040   } else {
2041     jchild = (Dali::Actor *) &child;
2042     jdimension = (int)dimension;
2043     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2044     c_result = (float)jresult;
2045   }
2046   return c_result;
2047 }
2048
2049 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2050   float c_result = SwigValueInit< float >() ;
2051   float jresult = 0 ;
2052   float jwidth  ;
2053
2054   if (!swig_callbackGetHeightForWidth) {
2055     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2056   } else {
2057     jwidth = width;
2058     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2059     c_result = (float)jresult;
2060   }
2061   return c_result;
2062 }
2063
2064 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2065   float c_result = SwigValueInit< float >() ;
2066   float jresult = 0 ;
2067   float jheight  ;
2068
2069   if (!swig_callbackGetWidthForHeight) {
2070     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2071   } else {
2072     jheight = height;
2073     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2074     c_result = (float)jresult;
2075   }
2076   return c_result;
2077 }
2078
2079 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2080   bool c_result = SwigValueInit< bool >() ;
2081   unsigned int jresult = 0 ;
2082   int jdimension  ;
2083
2084   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2085     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2086   } else {
2087     jdimension = (int)dimension;
2088     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2089     c_result = jresult ? true : false;
2090   }
2091   return c_result;
2092 }
2093
2094 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2095   int jdimension  ;
2096
2097   if (!swig_callbackOnCalculateRelayoutSize) {
2098     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2099     return;
2100   } else {
2101     jdimension = (int)dimension;
2102     swig_callbackOnCalculateRelayoutSize(jdimension);
2103   }
2104 }
2105
2106 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2107   float jsize  ;
2108   int jdimension  ;
2109
2110   if (!swig_callbackOnLayoutNegotiated) {
2111     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2112     return;
2113   } else {
2114     jsize = size;
2115     jdimension = (int)dimension;
2116     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2117   }
2118 }
2119
2120 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2121   return Dali::CustomActorImpl::GetExtension();
2122 }
2123
2124 void SwigDirector_ViewImpl::OnInitialize() {
2125   if (!swig_callbackOnInitialize) {
2126     Dali::Toolkit::Internal::Control::OnInitialize();
2127     return;
2128   } else {
2129     swig_callbackOnInitialize();
2130   }
2131 }
2132
2133 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2134   void * jchild = 0 ;
2135
2136   if (!swig_callbackOnControlChildAdd) {
2137     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2138     return;
2139   } else {
2140     jchild = (Dali::Actor *) &child;
2141     swig_callbackOnControlChildAdd(jchild);
2142   }
2143 }
2144
2145 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2146   void * jchild = 0 ;
2147
2148   if (!swig_callbackOnControlChildRemove) {
2149     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2150     return;
2151   } else {
2152     jchild = (Dali::Actor *) &child;
2153     swig_callbackOnControlChildRemove(jchild);
2154   }
2155 }
2156
2157 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2158   void * jstyleManager  ;
2159   int jchange  ;
2160
2161   if (!swig_callbackOnStyleChange) {
2162     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2163     return;
2164   } else {
2165     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2166     jchange = (int)change;
2167     swig_callbackOnStyleChange(jstyleManager, jchange);
2168   }
2169 }
2170
2171 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2172   bool c_result = SwigValueInit< bool >() ;
2173   unsigned int jresult = 0 ;
2174
2175   if (!swig_callbackOnAccessibilityActivated) {
2176     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2177   } else {
2178     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2179     c_result = jresult ? true : false;
2180   }
2181   return c_result;
2182 }
2183
2184 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2185   bool c_result = SwigValueInit< bool >() ;
2186   unsigned int jresult = 0 ;
2187   void * jgesture  ;
2188
2189   if (!swig_callbackOnAccessibilityPan) {
2190     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2191   } else {
2192     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2193     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2194     c_result = jresult ? true : false;
2195   }
2196   return c_result;
2197 }
2198
2199 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2200   bool c_result = SwigValueInit< bool >() ;
2201   unsigned int jresult = 0 ;
2202   void * jtouchEvent = 0 ;
2203
2204   if (!swig_callbackOnAccessibilityTouch) {
2205     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2206   } else {
2207     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2208     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2209     c_result = jresult ? true : false;
2210   }
2211   return c_result;
2212 }
2213
2214 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2215   bool c_result = SwigValueInit< bool >() ;
2216   unsigned int jresult = 0 ;
2217   unsigned int jisIncrease  ;
2218
2219   if (!swig_callbackOnAccessibilityValueChange) {
2220     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2221   } else {
2222     jisIncrease = isIncrease;
2223     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2224     c_result = jresult ? true : false;
2225   }
2226   return c_result;
2227 }
2228
2229 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2230   bool c_result = SwigValueInit< bool >() ;
2231   unsigned int jresult = 0 ;
2232
2233   if (!swig_callbackOnAccessibilityZoom) {
2234     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2235   } else {
2236     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2237     c_result = jresult ? true : false;
2238   }
2239   return c_result;
2240 }
2241
2242 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2243   if (!swig_callbackOnKeyInputFocusGained) {
2244     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2245     return;
2246   } else {
2247     swig_callbackOnKeyInputFocusGained();
2248   }
2249 }
2250
2251 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2252   if (!swig_callbackOnKeyInputFocusLost) {
2253     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2254     return;
2255   } else {
2256     swig_callbackOnKeyInputFocusLost();
2257   }
2258 }
2259
2260 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2261   Dali::Actor c_result ;
2262   void * jresult = 0 ;
2263   void * jcurrentFocusedActor  ;
2264   int jdirection  ;
2265   unsigned int jloopEnabled  ;
2266
2267   if (!swig_callbackGetNextKeyboardFocusableActor) {
2268     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2269   } else {
2270     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2271     jdirection = (int)direction;
2272     jloopEnabled = loopEnabled;
2273     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2274     if (!jresult) {
2275       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2276       return c_result;
2277     }
2278     c_result = *(Dali::Actor *)jresult;
2279   }
2280   return c_result;
2281 }
2282
2283 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2284   void * jcommitedFocusableActor  ;
2285
2286   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2287     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2288     return;
2289   } else {
2290     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2291     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2292   }
2293 }
2294
2295 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2296   bool c_result = SwigValueInit< bool >() ;
2297   unsigned int jresult = 0 ;
2298
2299   if (!swig_callbackOnKeyboardEnter) {
2300     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2301   } else {
2302     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2303     c_result = jresult ? true : false;
2304   }
2305   return c_result;
2306 }
2307
2308 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2309   void * jpinch = 0 ;
2310
2311   if (!swig_callbackOnPinch) {
2312     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2313     return;
2314   } else {
2315     jpinch = (Dali::PinchGesture *) &pinch;
2316     swig_callbackOnPinch(jpinch);
2317   }
2318 }
2319
2320 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2321   void * jpan = 0 ;
2322
2323   if (!swig_callbackOnPan) {
2324     Dali::Toolkit::Internal::Control::OnPan(pan);
2325     return;
2326   } else {
2327     jpan = (Dali::PanGesture *) &pan;
2328     swig_callbackOnPan(jpan);
2329   }
2330 }
2331
2332 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2333   void * jtap = 0 ;
2334
2335   if (!swig_callbackOnTap) {
2336     Dali::Toolkit::Internal::Control::OnTap(tap);
2337     return;
2338   } else {
2339     jtap = (Dali::TapGesture *) &tap;
2340     swig_callbackOnTap(jtap);
2341   }
2342 }
2343
2344 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2345   void * jlongPress = 0 ;
2346
2347   if (!swig_callbackOnLongPress) {
2348     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2349     return;
2350   } else {
2351     jlongPress = (Dali::LongPressGesture *) &longPress;
2352     swig_callbackOnLongPress(jlongPress);
2353   }
2354 }
2355
2356 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2357   void * jslotObserver = 0 ;
2358   void * jcallback = 0 ;
2359
2360   if (!swig_callbackSignalConnected) {
2361     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2362     return;
2363   } else {
2364     jslotObserver = (void *) slotObserver;
2365     jcallback = (void *) callback;
2366     swig_callbackSignalConnected(jslotObserver, jcallback);
2367   }
2368 }
2369
2370 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2371   void * jslotObserver = 0 ;
2372   void * jcallback = 0 ;
2373
2374   if (!swig_callbackSignalDisconnected) {
2375     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2376     return;
2377   } else {
2378     jslotObserver = (void *) slotObserver;
2379     jcallback = (void *) callback;
2380     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2381   }
2382 }
2383
2384 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2385   return Dali::Toolkit::Internal::Control::GetControlExtension();
2386 }
2387
2388 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2389   swig_callbackOnStageConnection = callbackOnStageConnection;
2390   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2391   swig_callbackOnChildAdd = callbackOnChildAdd;
2392   swig_callbackOnChildRemove = callbackOnChildRemove;
2393   swig_callbackOnPropertySet = callbackOnPropertySet;
2394   swig_callbackOnSizeSet = callbackOnSizeSet;
2395   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2396   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2397   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2398   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2399   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2400   swig_callbackOnRelayout = callbackOnRelayout;
2401   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2402   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2403   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2404   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2405   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2406   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2407   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2408   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2409   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2410   swig_callbackOnInitialize = callbackOnInitialize;
2411   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2412   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2413   swig_callbackOnStyleChange = callbackOnStyleChange;
2414   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2415   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2416   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2417   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2418   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2419   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2420   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2421   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2422   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2423   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2424   swig_callbackOnPinch = callbackOnPinch;
2425   swig_callbackOnPan = callbackOnPan;
2426   swig_callbackOnTap = callbackOnTap;
2427   swig_callbackOnLongPress = callbackOnLongPress;
2428   swig_callbackSignalConnected = callbackSignalConnected;
2429   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2430 }
2431
2432 void SwigDirector_ViewImpl::swig_init_callbacks() {
2433   swig_callbackOnStageConnection = 0;
2434   swig_callbackOnStageDisconnection = 0;
2435   swig_callbackOnChildAdd = 0;
2436   swig_callbackOnChildRemove = 0;
2437   swig_callbackOnPropertySet = 0;
2438   swig_callbackOnSizeSet = 0;
2439   swig_callbackOnSizeAnimation = 0;
2440   swig_callbackOnTouchEvent = 0;
2441   swig_callbackOnHoverEvent = 0;
2442   swig_callbackOnKeyEvent = 0;
2443   swig_callbackOnWheelEvent = 0;
2444   swig_callbackOnRelayout = 0;
2445   swig_callbackOnSetResizePolicy = 0;
2446   swig_callbackGetNaturalSize = 0;
2447   swig_callbackCalculateChildSize = 0;
2448   swig_callbackGetHeightForWidth = 0;
2449   swig_callbackGetWidthForHeight = 0;
2450   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2451   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2452   swig_callbackOnCalculateRelayoutSize = 0;
2453   swig_callbackOnLayoutNegotiated = 0;
2454   swig_callbackOnInitialize = 0;
2455   swig_callbackOnControlChildAdd = 0;
2456   swig_callbackOnControlChildRemove = 0;
2457   swig_callbackOnStyleChange = 0;
2458   swig_callbackOnAccessibilityActivated = 0;
2459   swig_callbackOnAccessibilityPan = 0;
2460   swig_callbackOnAccessibilityTouch = 0;
2461   swig_callbackOnAccessibilityValueChange = 0;
2462   swig_callbackOnAccessibilityZoom = 0;
2463   swig_callbackOnKeyInputFocusGained = 0;
2464   swig_callbackOnKeyInputFocusLost = 0;
2465   swig_callbackGetNextKeyboardFocusableActor = 0;
2466   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2467   swig_callbackOnKeyboardEnter = 0;
2468   swig_callbackOnPinch = 0;
2469   swig_callbackOnPan = 0;
2470   swig_callbackOnTap = 0;
2471   swig_callbackOnLongPress = 0;
2472   swig_callbackSignalConnected = 0;
2473   swig_callbackSignalDisconnected = 0;
2474 }
2475
2476 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2477   swig_init_callbacks();
2478 }
2479
2480 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2481
2482 }
2483
2484
2485 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2486   unsigned int c_result = SwigValueInit< unsigned int >() ;
2487   unsigned int jresult = 0 ;
2488
2489   if (!swig_callbackGetNumberOfItems) {
2490     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2491   } else {
2492     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2493     c_result = (unsigned int)jresult;
2494   }
2495   return c_result;
2496 }
2497
2498 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2499   Dali::Actor c_result ;
2500   void * jresult = 0 ;
2501   unsigned int jitemId  ;
2502
2503   if (!swig_callbackNewItem) {
2504     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2505   } else {
2506     jitemId = itemId;
2507     jresult = (void *) swig_callbackNewItem(jitemId);
2508     if (!jresult) {
2509       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2510       return c_result;
2511     }
2512     c_result = *(Dali::Actor *)jresult;
2513   }
2514   return c_result;
2515 }
2516
2517 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2518   unsigned int jitemId  ;
2519   void * jactor  ;
2520
2521   if (!swig_callbackItemReleased) {
2522     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2523     return;
2524   } else {
2525     jitemId = itemId;
2526     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2527     swig_callbackItemReleased(jitemId, jactor);
2528   }
2529 }
2530
2531 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2532   return Dali::Toolkit::ItemFactory::GetExtension();
2533 }
2534
2535 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2536   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2537   swig_callbackNewItem = callbackNewItem;
2538   swig_callbackItemReleased = callbackItemReleased;
2539 }
2540
2541 void SwigDirector_ItemFactory::swig_init_callbacks() {
2542   swig_callbackGetNumberOfItems = 0;
2543   swig_callbackNewItem = 0;
2544   swig_callbackItemReleased = 0;
2545 }
2546
2547 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2548   swig_init_callbacks();
2549 }
2550
2551 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2552
2553 }
2554
2555
2556 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2557   Dali::Actor c_result ;
2558   void * jresult = 0 ;
2559   void * jcurrent  ;
2560   void * jproposed  ;
2561   int jdirection  ;
2562
2563   if (!swig_callbackGetNextFocusableActor) {
2564     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2565   } else {
2566     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2567     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2568     jdirection = (int)direction;
2569     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2570     if (!jresult) {
2571       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::Actor! Next focus will be NULL, please be cautious to handle the keyboard foucs! ", __FILE__, __LINE__);
2572       return c_result;
2573     }
2574     c_result = *(Dali::Actor *)jresult;
2575   }
2576   return c_result;
2577 }
2578
2579 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2580   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2581 }
2582
2583 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2584   swig_callbackGetNextFocusableActor = 0;
2585 }
2586
2587
2588 #ifdef __cplusplus
2589 extern "C" {
2590 #endif
2591
2592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2593   void * jresult ;
2594   floatp *result = 0 ;
2595
2596   {
2597     try {
2598       result = (floatp *)new_floatp();
2599     } catch (std::out_of_range& e) {
2600       {
2601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2602       };
2603     } catch (std::exception& e) {
2604       {
2605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2606       };
2607     } catch (DaliException e) {
2608       {
2609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2610       };
2611     } catch (...) {
2612       {
2613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2614       };
2615     }
2616   }
2617   jresult = (void *)result;
2618   return jresult;
2619 }
2620
2621
2622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2623   floatp *arg1 = (floatp *) 0 ;
2624
2625   arg1 = (floatp *)jarg1;
2626   {
2627     try {
2628       delete_floatp(arg1);
2629     } catch (std::out_of_range& e) {
2630       {
2631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2632       };
2633     } catch (std::exception& e) {
2634       {
2635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2636       };
2637     } catch (Dali::DaliException e) {
2638       {
2639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2640       };
2641     } catch (...) {
2642       {
2643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2644       };
2645     }
2646   }
2647
2648 }
2649
2650
2651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2652   floatp *arg1 = (floatp *) 0 ;
2653   float arg2 ;
2654
2655   arg1 = (floatp *)jarg1;
2656   arg2 = (float)jarg2;
2657   {
2658     try {
2659       floatp_assign(arg1,arg2);
2660     } catch (std::out_of_range& e) {
2661       {
2662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2663       };
2664     } catch (std::exception& e) {
2665       {
2666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2667       };
2668     } catch (Dali::DaliException e) {
2669       {
2670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2671       };
2672     } catch (...) {
2673       {
2674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2675       };
2676     }
2677   }
2678
2679 }
2680
2681
2682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2683   float jresult ;
2684   floatp *arg1 = (floatp *) 0 ;
2685   float result;
2686
2687   arg1 = (floatp *)jarg1;
2688   {
2689     try {
2690       result = (float)floatp_value(arg1);
2691     } catch (std::out_of_range& e) {
2692       {
2693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2694       };
2695     } catch (std::exception& e) {
2696       {
2697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2698       };
2699     } catch (DaliException e) {
2700       {
2701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2702       };
2703     } catch (...) {
2704       {
2705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2706       };
2707     }
2708   }
2709   jresult = result;
2710   return jresult;
2711 }
2712
2713
2714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2715   void * jresult ;
2716   floatp *arg1 = (floatp *) 0 ;
2717   float *result = 0 ;
2718
2719   arg1 = (floatp *)jarg1;
2720   {
2721     try {
2722       result = (float *)floatp_cast(arg1);
2723     } catch (std::out_of_range& e) {
2724       {
2725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2726       };
2727     } catch (std::exception& e) {
2728       {
2729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2730       };
2731     } catch (Dali::DaliException e) {
2732       {
2733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2734       };
2735     } catch (...) {
2736       {
2737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2738       };
2739     }
2740   }
2741
2742   jresult = (void *)result;
2743   return jresult;
2744 }
2745
2746
2747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2748   void * jresult ;
2749   float *arg1 = (float *) 0 ;
2750   floatp *result = 0 ;
2751
2752   arg1 = (float *)jarg1;
2753   {
2754     try {
2755       result = (floatp *)floatp_frompointer(arg1);
2756     } catch (std::out_of_range& e) {
2757       {
2758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2759       };
2760     } catch (std::exception& e) {
2761       {
2762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2763       };
2764     } catch (Dali::DaliException e) {
2765       {
2766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2767       };
2768     } catch (...) {
2769       {
2770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2771       };
2772     }
2773   }
2774
2775   jresult = (void *)result;
2776   return jresult;
2777 }
2778
2779
2780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2781   void * jresult ;
2782   intp *result = 0 ;
2783
2784   {
2785     try {
2786       result = (intp *)new_intp();
2787     } catch (std::out_of_range& e) {
2788       {
2789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2790       };
2791     } catch (std::exception& e) {
2792       {
2793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2794       };
2795     } catch (Dali::DaliException e) {
2796       {
2797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2798       };
2799     } catch (...) {
2800       {
2801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2802       };
2803     }
2804   }
2805
2806   jresult = (void *)result;
2807   return jresult;
2808 }
2809
2810
2811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2812   intp *arg1 = (intp *) 0 ;
2813
2814   arg1 = (intp *)jarg1;
2815   {
2816     try {
2817       delete_intp(arg1);
2818     } catch (std::out_of_range& e) {
2819       {
2820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2821       };
2822     } catch (std::exception& e) {
2823       {
2824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2825       };
2826     } catch (Dali::DaliException e) {
2827       {
2828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2829       };
2830     } catch (...) {
2831       {
2832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2833       };
2834     }
2835   }
2836
2837 }
2838
2839
2840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2841   intp *arg1 = (intp *) 0 ;
2842   int arg2 ;
2843
2844   arg1 = (intp *)jarg1;
2845   arg2 = (int)jarg2;
2846   {
2847     try {
2848       intp_assign(arg1,arg2);
2849     } catch (std::out_of_range& e) {
2850       {
2851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2852       };
2853     } catch (std::exception& e) {
2854       {
2855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2856       };
2857     } catch (Dali::DaliException e) {
2858       {
2859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2860       };
2861     } catch (...) {
2862       {
2863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2864       };
2865     }
2866   }
2867
2868 }
2869
2870
2871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2872   int jresult ;
2873   intp *arg1 = (intp *) 0 ;
2874   int result;
2875
2876   arg1 = (intp *)jarg1;
2877   {
2878     try {
2879       result = (int)intp_value(arg1);
2880     } catch (std::out_of_range& e) {
2881       {
2882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2883       };
2884     } catch (std::exception& e) {
2885       {
2886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2887       };
2888     } catch (Dali::DaliException e) {
2889       {
2890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2891       };
2892     } catch (...) {
2893       {
2894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2895       };
2896     }
2897   }
2898
2899   jresult = result;
2900   return jresult;
2901 }
2902
2903
2904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2905   void * jresult ;
2906   intp *arg1 = (intp *) 0 ;
2907   int *result = 0 ;
2908
2909   arg1 = (intp *)jarg1;
2910   {
2911     try {
2912       result = (int *)intp_cast(arg1);
2913     } catch (std::out_of_range& e) {
2914       {
2915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2916       };
2917     } catch (std::exception& e) {
2918       {
2919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2920       };
2921     } catch (Dali::DaliException e) {
2922       {
2923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2924       };
2925     } catch (...) {
2926       {
2927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2928       };
2929     }
2930   }
2931
2932   jresult = (void *)result;
2933   return jresult;
2934 }
2935
2936
2937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2938   void * jresult ;
2939   int *arg1 = (int *) 0 ;
2940   intp *result = 0 ;
2941
2942   arg1 = (int *)jarg1;
2943   {
2944     try {
2945       result = (intp *)intp_frompointer(arg1);
2946     } catch (std::out_of_range& e) {
2947       {
2948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2949       };
2950     } catch (std::exception& e) {
2951       {
2952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2953       };
2954     } catch (Dali::DaliException e) {
2955       {
2956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2957       };
2958     } catch (...) {
2959       {
2960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2961       };
2962     }
2963   }
2964
2965   jresult = (void *)result;
2966   return jresult;
2967 }
2968
2969
2970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2971   void * jresult ;
2972   doublep *result = 0 ;
2973
2974   {
2975     try {
2976       result = (doublep *)new_doublep();
2977     } catch (std::out_of_range& e) {
2978       {
2979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2980       };
2981     } catch (std::exception& e) {
2982       {
2983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2984       };
2985     } catch (Dali::DaliException e) {
2986       {
2987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2988       };
2989     } catch (...) {
2990       {
2991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2992       };
2993     }
2994   }
2995
2996   jresult = (void *)result;
2997   return jresult;
2998 }
2999
3000
3001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
3002   doublep *arg1 = (doublep *) 0 ;
3003
3004   arg1 = (doublep *)jarg1;
3005   {
3006     try {
3007       delete_doublep(arg1);
3008     } catch (std::out_of_range& e) {
3009       {
3010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3011       };
3012     } catch (std::exception& e) {
3013       {
3014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3015       };
3016     } catch (Dali::DaliException e) {
3017       {
3018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3019       };
3020     } catch (...) {
3021       {
3022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3023       };
3024     }
3025   }
3026
3027 }
3028
3029
3030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3031   doublep *arg1 = (doublep *) 0 ;
3032   double arg2 ;
3033
3034   arg1 = (doublep *)jarg1;
3035   arg2 = (double)jarg2;
3036   {
3037     try {
3038       doublep_assign(arg1,arg2);
3039     } catch (std::out_of_range& e) {
3040       {
3041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3042       };
3043     } catch (std::exception& e) {
3044       {
3045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3046       };
3047     } catch (Dali::DaliException e) {
3048       {
3049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3050       };
3051     } catch (...) {
3052       {
3053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3054       };
3055     }
3056   }
3057
3058 }
3059
3060
3061 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3062   double jresult ;
3063   doublep *arg1 = (doublep *) 0 ;
3064   double result;
3065
3066   arg1 = (doublep *)jarg1;
3067   {
3068     try {
3069       result = (double)doublep_value(arg1);
3070     } catch (std::out_of_range& e) {
3071       {
3072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3073       };
3074     } catch (std::exception& e) {
3075       {
3076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3077       };
3078     } catch (Dali::DaliException e) {
3079       {
3080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3081       };
3082     } catch (...) {
3083       {
3084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3085       };
3086     }
3087   }
3088
3089   jresult = result;
3090   return jresult;
3091 }
3092
3093
3094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3095   void * jresult ;
3096   doublep *arg1 = (doublep *) 0 ;
3097   double *result = 0 ;
3098
3099   arg1 = (doublep *)jarg1;
3100   {
3101     try {
3102       result = (double *)doublep_cast(arg1);
3103     } catch (std::out_of_range& e) {
3104       {
3105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3106       };
3107     } catch (std::exception& e) {
3108       {
3109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3110       };
3111     } catch (Dali::DaliException e) {
3112       {
3113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3114       };
3115     } catch (...) {
3116       {
3117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3118       };
3119     }
3120   }
3121
3122   jresult = (void *)result;
3123   return jresult;
3124 }
3125
3126
3127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3128   void * jresult ;
3129   double *arg1 = (double *) 0 ;
3130   doublep *result = 0 ;
3131
3132   arg1 = (double *)jarg1;
3133   {
3134     try {
3135       result = (doublep *)doublep_frompointer(arg1);
3136     } catch (std::out_of_range& e) {
3137       {
3138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3139       };
3140     } catch (std::exception& e) {
3141       {
3142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3143       };
3144     } catch (Dali::DaliException e) {
3145       {
3146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3147       };
3148     } catch (...) {
3149       {
3150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3151       };
3152     }
3153   }
3154
3155   jresult = (void *)result;
3156   return jresult;
3157 }
3158
3159
3160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3161   void * jresult ;
3162   uintp *result = 0 ;
3163
3164   {
3165     try {
3166       result = (uintp *)new_uintp();
3167     } catch (std::out_of_range& e) {
3168       {
3169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3170       };
3171     } catch (std::exception& e) {
3172       {
3173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3174       };
3175     } catch (Dali::DaliException e) {
3176       {
3177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3178       };
3179     } catch (...) {
3180       {
3181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3182       };
3183     }
3184   }
3185
3186   jresult = (void *)result;
3187   return jresult;
3188 }
3189
3190
3191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3192   uintp *arg1 = (uintp *) 0 ;
3193
3194   arg1 = (uintp *)jarg1;
3195   {
3196     try {
3197       delete_uintp(arg1);
3198     } catch (std::out_of_range& e) {
3199       {
3200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3201       };
3202     } catch (std::exception& e) {
3203       {
3204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3205       };
3206     } catch (Dali::DaliException e) {
3207       {
3208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3209       };
3210     } catch (...) {
3211       {
3212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3213       };
3214     }
3215   }
3216
3217 }
3218
3219
3220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3221   uintp *arg1 = (uintp *) 0 ;
3222   unsigned int arg2 ;
3223
3224   arg1 = (uintp *)jarg1;
3225   arg2 = (unsigned int)jarg2;
3226   {
3227     try {
3228       uintp_assign(arg1,arg2);
3229     } catch (std::out_of_range& e) {
3230       {
3231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3232       };
3233     } catch (std::exception& e) {
3234       {
3235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3236       };
3237     } catch (Dali::DaliException e) {
3238       {
3239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3240       };
3241     } catch (...) {
3242       {
3243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3244       };
3245     }
3246   }
3247
3248 }
3249
3250
3251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3252   unsigned int jresult ;
3253   uintp *arg1 = (uintp *) 0 ;
3254   unsigned int result;
3255
3256   arg1 = (uintp *)jarg1;
3257   {
3258     try {
3259       result = (unsigned int)uintp_value(arg1);
3260     } catch (std::out_of_range& e) {
3261       {
3262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3263       };
3264     } catch (std::exception& e) {
3265       {
3266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3267       };
3268     } catch (Dali::DaliException e) {
3269       {
3270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3271       };
3272     } catch (...) {
3273       {
3274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3275       };
3276     }
3277   }
3278
3279   jresult = result;
3280   return jresult;
3281 }
3282
3283
3284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3285   void * jresult ;
3286   uintp *arg1 = (uintp *) 0 ;
3287   unsigned int *result = 0 ;
3288
3289   arg1 = (uintp *)jarg1;
3290   {
3291     try {
3292       result = (unsigned int *)uintp_cast(arg1);
3293     } catch (std::out_of_range& e) {
3294       {
3295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3296       };
3297     } catch (std::exception& e) {
3298       {
3299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3300       };
3301     } catch (Dali::DaliException e) {
3302       {
3303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3304       };
3305     } catch (...) {
3306       {
3307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3308       };
3309     }
3310   }
3311
3312   jresult = (void *)result;
3313   return jresult;
3314 }
3315
3316
3317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3318   void * jresult ;
3319   unsigned int *arg1 = (unsigned int *) 0 ;
3320   uintp *result = 0 ;
3321
3322   arg1 = (unsigned int *)jarg1;
3323   {
3324     try {
3325       result = (uintp *)uintp_frompointer(arg1);
3326     } catch (std::out_of_range& e) {
3327       {
3328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3329       };
3330     } catch (std::exception& e) {
3331       {
3332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3333       };
3334     } catch (Dali::DaliException e) {
3335       {
3336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3337       };
3338     } catch (...) {
3339       {
3340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3341       };
3342     }
3343   }
3344
3345   jresult = (void *)result;
3346   return jresult;
3347 }
3348
3349
3350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3351   void * jresult ;
3352   ushortp *result = 0 ;
3353
3354   {
3355     try {
3356       result = (ushortp *)new_ushortp();
3357     } catch (std::out_of_range& e) {
3358       {
3359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3360       };
3361     } catch (std::exception& e) {
3362       {
3363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3364       };
3365     } catch (Dali::DaliException e) {
3366       {
3367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3368       };
3369     } catch (...) {
3370       {
3371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3372       };
3373     }
3374   }
3375
3376   jresult = (void *)result;
3377   return jresult;
3378 }
3379
3380
3381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3382   ushortp *arg1 = (ushortp *) 0 ;
3383
3384   arg1 = (ushortp *)jarg1;
3385   {
3386     try {
3387       delete_ushortp(arg1);
3388     } catch (std::out_of_range& e) {
3389       {
3390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3391       };
3392     } catch (std::exception& e) {
3393       {
3394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3395       };
3396     } catch (Dali::DaliException e) {
3397       {
3398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3399       };
3400     } catch (...) {
3401       {
3402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3403       };
3404     }
3405   }
3406
3407 }
3408
3409
3410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3411   ushortp *arg1 = (ushortp *) 0 ;
3412   unsigned short arg2 ;
3413
3414   arg1 = (ushortp *)jarg1;
3415   arg2 = (unsigned short)jarg2;
3416   {
3417     try {
3418       ushortp_assign(arg1,arg2);
3419     } catch (std::out_of_range& e) {
3420       {
3421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3422       };
3423     } catch (std::exception& e) {
3424       {
3425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3426       };
3427     } catch (Dali::DaliException e) {
3428       {
3429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3430       };
3431     } catch (...) {
3432       {
3433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3434       };
3435     }
3436   }
3437
3438 }
3439
3440
3441 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3442   unsigned short jresult ;
3443   ushortp *arg1 = (ushortp *) 0 ;
3444   unsigned short result;
3445
3446   arg1 = (ushortp *)jarg1;
3447   {
3448     try {
3449       result = (unsigned short)ushortp_value(arg1);
3450     } catch (std::out_of_range& e) {
3451       {
3452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3453       };
3454     } catch (std::exception& e) {
3455       {
3456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3457       };
3458     } catch (Dali::DaliException e) {
3459       {
3460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3461       };
3462     } catch (...) {
3463       {
3464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3465       };
3466     }
3467   }
3468
3469   jresult = result;
3470   return jresult;
3471 }
3472
3473
3474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3475   void * jresult ;
3476   ushortp *arg1 = (ushortp *) 0 ;
3477   unsigned short *result = 0 ;
3478
3479   arg1 = (ushortp *)jarg1;
3480   {
3481     try {
3482       result = (unsigned short *)ushortp_cast(arg1);
3483     } catch (std::out_of_range& e) {
3484       {
3485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3486       };
3487     } catch (std::exception& e) {
3488       {
3489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3490       };
3491     } catch (Dali::DaliException e) {
3492       {
3493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3494       };
3495     } catch (...) {
3496       {
3497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3498       };
3499     }
3500   }
3501
3502   jresult = (void *)result;
3503   return jresult;
3504 }
3505
3506
3507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3508   void * jresult ;
3509   unsigned short *arg1 = (unsigned short *) 0 ;
3510   ushortp *result = 0 ;
3511
3512   arg1 = (unsigned short *)jarg1;
3513   {
3514     try {
3515       result = (ushortp *)ushortp_frompointer(arg1);
3516     } catch (std::out_of_range& e) {
3517       {
3518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3519       };
3520     } catch (std::exception& e) {
3521       {
3522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3523       };
3524     } catch (Dali::DaliException e) {
3525       {
3526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3527       };
3528     } catch (...) {
3529       {
3530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3531       };
3532     }
3533   }
3534
3535   jresult = (void *)result;
3536   return jresult;
3537 }
3538
3539
3540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3541   unsigned int jresult ;
3542   int arg1 ;
3543   unsigned int result;
3544
3545   arg1 = (int)jarg1;
3546   {
3547     try {
3548       result = (unsigned int)int_to_uint(arg1);
3549     } catch (std::out_of_range& e) {
3550       {
3551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3552       };
3553     } catch (std::exception& e) {
3554       {
3555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3556       };
3557     } catch (Dali::DaliException e) {
3558       {
3559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3560       };
3561     } catch (...) {
3562       {
3563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3564       };
3565     }
3566   }
3567
3568   jresult = result;
3569   return jresult;
3570 }
3571
3572
3573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3574   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3575
3576   arg1 = (Dali::RefObject *)jarg1;
3577   {
3578     try {
3579       (arg1)->Reference();
3580     } catch (std::out_of_range& e) {
3581       {
3582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3583       };
3584     } catch (std::exception& e) {
3585       {
3586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3587       };
3588     } catch (Dali::DaliException e) {
3589       {
3590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3591       };
3592     } catch (...) {
3593       {
3594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3595       };
3596     }
3597   }
3598
3599 }
3600
3601
3602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3603   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3604
3605   arg1 = (Dali::RefObject *)jarg1;
3606   {
3607     try {
3608       (arg1)->Unreference();
3609     } catch (std::out_of_range& e) {
3610       {
3611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3612       };
3613     } catch (std::exception& e) {
3614       {
3615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3616       };
3617     } catch (Dali::DaliException e) {
3618       {
3619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3620       };
3621     } catch (...) {
3622       {
3623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3624       };
3625     }
3626   }
3627
3628 }
3629
3630
3631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3632   int jresult ;
3633   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3634   int result;
3635
3636   arg1 = (Dali::RefObject *)jarg1;
3637   {
3638     try {
3639       result = (int)(arg1)->ReferenceCount();
3640     } catch (std::out_of_range& e) {
3641       {
3642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3643       };
3644     } catch (std::exception& e) {
3645       {
3646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3647       };
3648     } catch (Dali::DaliException e) {
3649       {
3650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3651       };
3652     } catch (...) {
3653       {
3654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3655       };
3656     }
3657   }
3658
3659   jresult = result;
3660   return jresult;
3661 }
3662
3663
3664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3665   void * jresult ;
3666   Dali::Any *result = 0 ;
3667
3668   {
3669     try {
3670       result = (Dali::Any *)new Dali::Any();
3671     } catch (std::out_of_range& e) {
3672       {
3673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3674       };
3675     } catch (std::exception& e) {
3676       {
3677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3678       };
3679     } catch (Dali::DaliException e) {
3680       {
3681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3682       };
3683     } catch (...) {
3684       {
3685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3686       };
3687     }
3688   }
3689
3690   jresult = (void *)result;
3691   return jresult;
3692 }
3693
3694
3695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3696   Dali::Any *arg1 = (Dali::Any *) 0 ;
3697
3698   arg1 = (Dali::Any *)jarg1;
3699   {
3700     try {
3701       delete arg1;
3702     } catch (std::out_of_range& e) {
3703       {
3704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3705       };
3706     } catch (std::exception& e) {
3707       {
3708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3709       };
3710     } catch (Dali::DaliException e) {
3711       {
3712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3713       };
3714     } catch (...) {
3715       {
3716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3717       };
3718     }
3719   }
3720
3721 }
3722
3723
3724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3725   char *arg1 = (char *) 0 ;
3726
3727   arg1 = (char *)jarg1;
3728   {
3729     try {
3730       Dali::Any::AssertAlways((char const *)arg1);
3731     } catch (std::out_of_range& e) {
3732       {
3733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3734       };
3735     } catch (std::exception& e) {
3736       {
3737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3738       };
3739     } catch (Dali::DaliException e) {
3740       {
3741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3742       };
3743     } catch (...) {
3744       {
3745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3746       };
3747     }
3748   }
3749
3750 }
3751
3752
3753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3754   void * jresult ;
3755   Dali::Any *arg1 = 0 ;
3756   Dali::Any *result = 0 ;
3757
3758   arg1 = (Dali::Any *)jarg1;
3759   if (!arg1) {
3760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3761     return 0;
3762   }
3763   {
3764     try {
3765       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3766     } catch (std::out_of_range& e) {
3767       {
3768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3769       };
3770     } catch (std::exception& e) {
3771       {
3772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3773       };
3774     } catch (Dali::DaliException e) {
3775       {
3776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3777       };
3778     } catch (...) {
3779       {
3780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3781       };
3782     }
3783   }
3784
3785   jresult = (void *)result;
3786   return jresult;
3787 }
3788
3789
3790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3791   void * jresult ;
3792   Dali::Any *arg1 = (Dali::Any *) 0 ;
3793   Dali::Any *arg2 = 0 ;
3794   Dali::Any *result = 0 ;
3795
3796   arg1 = (Dali::Any *)jarg1;
3797   arg2 = (Dali::Any *)jarg2;
3798   if (!arg2) {
3799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3800     return 0;
3801   }
3802   {
3803     try {
3804       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3805     } catch (std::out_of_range& e) {
3806       {
3807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3808       };
3809     } catch (std::exception& e) {
3810       {
3811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3812       };
3813     } catch (Dali::DaliException e) {
3814       {
3815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3816       };
3817     } catch (...) {
3818       {
3819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3820       };
3821     }
3822   }
3823
3824   jresult = (void *)result;
3825   return jresult;
3826 }
3827
3828
3829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3830   void * jresult ;
3831   Dali::Any *arg1 = (Dali::Any *) 0 ;
3832   std::type_info *result = 0 ;
3833
3834   arg1 = (Dali::Any *)jarg1;
3835   {
3836     try {
3837       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3838     } catch (std::out_of_range& e) {
3839       {
3840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3841       };
3842     } catch (std::exception& e) {
3843       {
3844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3845       };
3846     } catch (Dali::DaliException e) {
3847       {
3848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3849       };
3850     } catch (...) {
3851       {
3852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3853       };
3854     }
3855   }
3856
3857   jresult = (void *)result;
3858   return jresult;
3859 }
3860
3861
3862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3863   unsigned int jresult ;
3864   Dali::Any *arg1 = (Dali::Any *) 0 ;
3865   bool result;
3866
3867   arg1 = (Dali::Any *)jarg1;
3868   {
3869     try {
3870       result = (bool)((Dali::Any const *)arg1)->Empty();
3871     } catch (std::out_of_range& e) {
3872       {
3873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3874       };
3875     } catch (std::exception& e) {
3876       {
3877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3878       };
3879     } catch (Dali::DaliException e) {
3880       {
3881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3882       };
3883     } catch (...) {
3884       {
3885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3886       };
3887     }
3888   }
3889
3890   jresult = result;
3891   return jresult;
3892 }
3893
3894
3895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3896   void * jresult ;
3897   std::type_info *arg1 = 0 ;
3898   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3899   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3900   Dali::Any::AnyContainerBase *result = 0 ;
3901
3902   arg1 = (std::type_info *)jarg1;
3903   if (!arg1) {
3904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3905     return 0;
3906   }
3907   arg2 = (Dali::Any::CloneFunc)jarg2;
3908   arg3 = (Dali::Any::DeleteFunc)jarg3;
3909   {
3910     try {
3911       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3912     } catch (std::out_of_range& e) {
3913       {
3914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3915       };
3916     } catch (std::exception& e) {
3917       {
3918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3919       };
3920     } catch (Dali::DaliException e) {
3921       {
3922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3923       };
3924     } catch (...) {
3925       {
3926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3927       };
3928     }
3929   }
3930
3931   jresult = (void *)result;
3932   return jresult;
3933 }
3934
3935
3936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3937   void * jresult ;
3938   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3939   std::type_info *result = 0 ;
3940
3941   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3942   {
3943     try {
3944       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3945     } catch (std::out_of_range& e) {
3946       {
3947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3948       };
3949     } catch (std::exception& e) {
3950       {
3951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3952       };
3953     } catch (Dali::DaliException e) {
3954       {
3955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3956       };
3957     } catch (...) {
3958       {
3959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3960       };
3961     }
3962   }
3963
3964   jresult = (void *)result;
3965   return jresult;
3966 }
3967
3968
3969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3970   void * jresult ;
3971   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3972   ::std::type_info *result = 0 ;
3973
3974   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3975   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3976   jresult = (void *)result;
3977   return jresult;
3978 }
3979
3980
3981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3982   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3983   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3984
3985   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3986   arg2 = (Dali::Any::CloneFunc)jarg2;
3987   if (arg1) (arg1)->mCloneFunc = arg2;
3988 }
3989
3990
3991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3992   void * jresult ;
3993   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3994   Dali::Any::CloneFunc result;
3995
3996   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3997   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3998   jresult = (void *)result;
3999   return jresult;
4000 }
4001
4002
4003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4004   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4005   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4006
4007   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4008   arg2 = (Dali::Any::DeleteFunc)jarg2;
4009   if (arg1) (arg1)->mDeleteFunc = arg2;
4010 }
4011
4012
4013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4014   void * jresult ;
4015   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4016   Dali::Any::DeleteFunc result;
4017
4018   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4019   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4020   jresult = (void *)result;
4021   return jresult;
4022 }
4023
4024
4025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4026   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4027
4028   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4029   {
4030     try {
4031       delete arg1;
4032     } catch (std::out_of_range& e) {
4033       {
4034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4035       };
4036     } catch (std::exception& e) {
4037       {
4038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4039       };
4040     } catch (Dali::DaliException e) {
4041       {
4042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4043       };
4044     } catch (...) {
4045       {
4046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4047       };
4048     }
4049   }
4050
4051 }
4052
4053
4054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4055   Dali::Any *arg1 = (Dali::Any *) 0 ;
4056   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4057
4058   arg1 = (Dali::Any *)jarg1;
4059   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4060   if (arg1) (arg1)->mContainer = arg2;
4061 }
4062
4063
4064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4065   void * jresult ;
4066   Dali::Any *arg1 = (Dali::Any *) 0 ;
4067   Dali::Any::AnyContainerBase *result = 0 ;
4068
4069   arg1 = (Dali::Any *)jarg1;
4070   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4071   jresult = (void *)result;
4072   return jresult;
4073 }
4074
4075
4076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4077   char *arg1 = (char *) 0 ;
4078   char *arg2 = (char *) 0 ;
4079
4080   arg1 = (char *)jarg1;
4081   arg2 = (char *)jarg2;
4082   {
4083     try {
4084       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4085     } catch (std::out_of_range& e) {
4086       {
4087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4088       };
4089     } catch (std::exception& e) {
4090       {
4091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4092       };
4093     } catch (Dali::DaliException e) {
4094       {
4095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4096       };
4097     } catch (...) {
4098       {
4099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4100       };
4101     }
4102   }
4103
4104 }
4105
4106
4107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4108   void * jresult ;
4109   char *arg1 = (char *) 0 ;
4110   char *arg2 = (char *) 0 ;
4111   Dali::DaliException *result = 0 ;
4112
4113   arg1 = (char *)jarg1;
4114   arg2 = (char *)jarg2;
4115   {
4116     try {
4117       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4118     } catch (std::out_of_range& e) {
4119       {
4120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4121       };
4122     } catch (std::exception& e) {
4123       {
4124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4125       };
4126     } catch (Dali::DaliException e) {
4127       {
4128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4129       };
4130     } catch (...) {
4131       {
4132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4133       };
4134     }
4135   }
4136
4137   jresult = (void *)result;
4138   return jresult;
4139 }
4140
4141
4142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4143   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4144   std::string arg2 = std::string(jarg2);
4145
4146   arg1 = (Dali::DaliException *)jarg1;
4147   {
4148     if (!arg2.empty()) {
4149       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4150     } else {
4151       arg1->location = 0;
4152     }
4153   }
4154 }
4155
4156 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4157   char * jresult ;
4158   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4159   char *result = 0 ;
4160
4161   arg1 = (Dali::DaliException *)jarg1;
4162   result = (char *) ((arg1)->location);
4163   jresult = SWIG_csharp_string_callback((const char *)result);
4164   return jresult;
4165 }
4166
4167
4168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4169   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4170   std::string arg2 = std::string(jarg2);
4171
4172   arg1 = (Dali::DaliException *)jarg1;
4173   {
4174     if (!arg2.empty()) {
4175       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4176     } else {
4177       arg1->condition = 0;
4178     }
4179   }
4180 }
4181
4182
4183 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4184   char * jresult ;
4185   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4186   char *result = 0 ;
4187
4188   arg1 = (Dali::DaliException *)jarg1;
4189   result = (char *) ((arg1)->condition);
4190   jresult = SWIG_csharp_string_callback((const char *)result);
4191   return jresult;
4192 }
4193
4194
4195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4196   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4197
4198   arg1 = (Dali::DaliException *)jarg1;
4199   {
4200     try {
4201       delete arg1;
4202     } catch (std::out_of_range& e) {
4203       {
4204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4205       };
4206     } catch (std::exception& e) {
4207       {
4208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4209       };
4210     } catch (Dali::DaliException e) {
4211       {
4212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4213       };
4214     } catch (...) {
4215       {
4216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4217       };
4218     }
4219   }
4220
4221 }
4222
4223
4224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4225   void * jresult ;
4226   Dali::Vector2 *result = 0 ;
4227
4228   {
4229     try {
4230       result = (Dali::Vector2 *)new Dali::Vector2();
4231     } catch (std::out_of_range& e) {
4232       {
4233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4234       };
4235     } catch (std::exception& e) {
4236       {
4237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4238       };
4239     } catch (Dali::DaliException e) {
4240       {
4241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4242       };
4243     } catch (...) {
4244       {
4245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4246       };
4247     }
4248   }
4249
4250   jresult = (void *)result;
4251   return jresult;
4252 }
4253
4254
4255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4256   void * jresult ;
4257   float arg1 ;
4258   float arg2 ;
4259   Dali::Vector2 *result = 0 ;
4260
4261   arg1 = (float)jarg1;
4262   arg2 = (float)jarg2;
4263   {
4264     try {
4265       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4266     } catch (std::out_of_range& e) {
4267       {
4268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4269       };
4270     } catch (std::exception& e) {
4271       {
4272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4273       };
4274     } catch (Dali::DaliException e) {
4275       {
4276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4277       };
4278     } catch (...) {
4279       {
4280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4281       };
4282     }
4283   }
4284
4285   jresult = (void *)result;
4286   return jresult;
4287 }
4288
4289
4290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4291   void * jresult ;
4292   float *arg1 = (float *) 0 ;
4293   Dali::Vector2 *result = 0 ;
4294
4295   arg1 = jarg1;
4296   {
4297     try {
4298       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4299     } catch (std::out_of_range& e) {
4300       {
4301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4302       };
4303     } catch (std::exception& e) {
4304       {
4305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4306       };
4307     } catch (Dali::DaliException e) {
4308       {
4309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4310       };
4311     } catch (...) {
4312       {
4313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4314       };
4315     }
4316   }
4317
4318   jresult = (void *)result;
4319
4320
4321   return jresult;
4322 }
4323
4324
4325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4326   void * jresult ;
4327   Dali::Vector3 *arg1 = 0 ;
4328   Dali::Vector2 *result = 0 ;
4329
4330   arg1 = (Dali::Vector3 *)jarg1;
4331   if (!arg1) {
4332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4333     return 0;
4334   }
4335   {
4336     try {
4337       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4338     } catch (std::out_of_range& e) {
4339       {
4340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4341       };
4342     } catch (std::exception& e) {
4343       {
4344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4345       };
4346     } catch (Dali::DaliException e) {
4347       {
4348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4349       };
4350     } catch (...) {
4351       {
4352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4353       };
4354     }
4355   }
4356
4357   jresult = (void *)result;
4358   return jresult;
4359 }
4360
4361
4362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4363   void * jresult ;
4364   Dali::Vector4 *arg1 = 0 ;
4365   Dali::Vector2 *result = 0 ;
4366
4367   arg1 = (Dali::Vector4 *)jarg1;
4368   if (!arg1) {
4369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4370     return 0;
4371   }
4372   {
4373     try {
4374       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4375     } catch (std::out_of_range& e) {
4376       {
4377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4378       };
4379     } catch (std::exception& e) {
4380       {
4381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4382       };
4383     } catch (Dali::DaliException e) {
4384       {
4385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4386       };
4387     } catch (...) {
4388       {
4389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4390       };
4391     }
4392   }
4393
4394   jresult = (void *)result;
4395   return jresult;
4396 }
4397
4398
4399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4400   void * jresult ;
4401   Dali::Vector2 *result = 0 ;
4402
4403   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4404   jresult = (void *)result;
4405   return jresult;
4406 }
4407
4408
4409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4410   void * jresult ;
4411   Dali::Vector2 *result = 0 ;
4412
4413   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4414   jresult = (void *)result;
4415   return jresult;
4416 }
4417
4418
4419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4420   void * jresult ;
4421   Dali::Vector2 *result = 0 ;
4422
4423   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4424   jresult = (void *)result;
4425   return jresult;
4426 }
4427
4428
4429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4430   void * jresult ;
4431   Dali::Vector2 *result = 0 ;
4432
4433   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4434   jresult = (void *)result;
4435   return jresult;
4436 }
4437
4438
4439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4440   void * jresult ;
4441   Dali::Vector2 *result = 0 ;
4442
4443   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4444   jresult = (void *)result;
4445   return jresult;
4446 }
4447
4448
4449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4450   void * jresult ;
4451   Dali::Vector2 *result = 0 ;
4452
4453   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4454   jresult = (void *)result;
4455   return jresult;
4456 }
4457
4458
4459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4460   void * jresult ;
4461   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4462   float *arg2 = (float *) 0 ;
4463   Dali::Vector2 *result = 0 ;
4464
4465   arg1 = (Dali::Vector2 *)jarg1;
4466   arg2 = jarg2;
4467   {
4468     try {
4469       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4470     } catch (std::out_of_range& e) {
4471       {
4472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4473       };
4474     } catch (std::exception& e) {
4475       {
4476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4477       };
4478     } catch (Dali::DaliException e) {
4479       {
4480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4481       };
4482     } catch (...) {
4483       {
4484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4485       };
4486     }
4487   }
4488
4489   jresult = (void *)result;
4490
4491
4492   return jresult;
4493 }
4494
4495
4496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4497   void * jresult ;
4498   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4499   Dali::Vector3 *arg2 = 0 ;
4500   Dali::Vector2 *result = 0 ;
4501
4502   arg1 = (Dali::Vector2 *)jarg1;
4503   arg2 = (Dali::Vector3 *)jarg2;
4504   if (!arg2) {
4505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4506     return 0;
4507   }
4508   {
4509     try {
4510       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4511     } catch (std::out_of_range& e) {
4512       {
4513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4514       };
4515     } catch (std::exception& e) {
4516       {
4517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4518       };
4519     } catch (Dali::DaliException e) {
4520       {
4521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4522       };
4523     } catch (...) {
4524       {
4525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4526       };
4527     }
4528   }
4529
4530   jresult = (void *)result;
4531   return jresult;
4532 }
4533
4534
4535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4536   void * jresult ;
4537   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4538   Dali::Vector4 *arg2 = 0 ;
4539   Dali::Vector2 *result = 0 ;
4540
4541   arg1 = (Dali::Vector2 *)jarg1;
4542   arg2 = (Dali::Vector4 *)jarg2;
4543   if (!arg2) {
4544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4545     return 0;
4546   }
4547   {
4548     try {
4549       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4550     } catch (std::out_of_range& e) {
4551       {
4552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4553       };
4554     } catch (std::exception& e) {
4555       {
4556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4557       };
4558     } catch (Dali::DaliException e) {
4559       {
4560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4561       };
4562     } catch (...) {
4563       {
4564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4565       };
4566     }
4567   }
4568
4569   jresult = (void *)result;
4570   return jresult;
4571 }
4572
4573
4574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4575   void * jresult ;
4576   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4577   Dali::Vector2 *arg2 = 0 ;
4578   Dali::Vector2 result;
4579
4580   arg1 = (Dali::Vector2 *)jarg1;
4581   arg2 = (Dali::Vector2 *)jarg2;
4582   if (!arg2) {
4583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4584     return 0;
4585   }
4586   {
4587     try {
4588       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4589     } catch (std::out_of_range& e) {
4590       {
4591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4592       };
4593     } catch (std::exception& e) {
4594       {
4595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4596       };
4597     } catch (Dali::DaliException e) {
4598       {
4599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4600       };
4601     } catch (...) {
4602       {
4603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4604       };
4605     }
4606   }
4607
4608   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4609   return jresult;
4610 }
4611
4612
4613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4614   void * jresult ;
4615   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4616   Dali::Vector2 *arg2 = 0 ;
4617   Dali::Vector2 *result = 0 ;
4618
4619   arg1 = (Dali::Vector2 *)jarg1;
4620   arg2 = (Dali::Vector2 *)jarg2;
4621   if (!arg2) {
4622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4623     return 0;
4624   }
4625   {
4626     try {
4627       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4628     } catch (std::out_of_range& e) {
4629       {
4630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4631       };
4632     } catch (std::exception& e) {
4633       {
4634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4635       };
4636     } catch (Dali::DaliException e) {
4637       {
4638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4639       };
4640     } catch (...) {
4641       {
4642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4643       };
4644     }
4645   }
4646
4647   jresult = (void *)result;
4648   return jresult;
4649 }
4650
4651
4652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4653   void * jresult ;
4654   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4655   Dali::Vector2 *arg2 = 0 ;
4656   Dali::Vector2 result;
4657
4658   arg1 = (Dali::Vector2 *)jarg1;
4659   arg2 = (Dali::Vector2 *)jarg2;
4660   if (!arg2) {
4661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4662     return 0;
4663   }
4664   {
4665     try {
4666       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4667     } catch (std::out_of_range& e) {
4668       {
4669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4670       };
4671     } catch (std::exception& e) {
4672       {
4673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4674       };
4675     } catch (Dali::DaliException e) {
4676       {
4677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4678       };
4679     } catch (...) {
4680       {
4681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4682       };
4683     }
4684   }
4685
4686   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4687   return jresult;
4688 }
4689
4690
4691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4692   void * jresult ;
4693   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4694   Dali::Vector2 *arg2 = 0 ;
4695   Dali::Vector2 *result = 0 ;
4696
4697   arg1 = (Dali::Vector2 *)jarg1;
4698   arg2 = (Dali::Vector2 *)jarg2;
4699   if (!arg2) {
4700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4701     return 0;
4702   }
4703   {
4704     try {
4705       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4706     } catch (std::out_of_range& e) {
4707       {
4708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4709       };
4710     } catch (std::exception& e) {
4711       {
4712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4713       };
4714     } catch (Dali::DaliException e) {
4715       {
4716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4717       };
4718     } catch (...) {
4719       {
4720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4721       };
4722     }
4723   }
4724
4725   jresult = (void *)result;
4726   return jresult;
4727 }
4728
4729
4730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4731   void * jresult ;
4732   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4733   Dali::Vector2 *arg2 = 0 ;
4734   Dali::Vector2 result;
4735
4736   arg1 = (Dali::Vector2 *)jarg1;
4737   arg2 = (Dali::Vector2 *)jarg2;
4738   if (!arg2) {
4739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4740     return 0;
4741   }
4742   {
4743     try {
4744       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4745     } catch (std::out_of_range& e) {
4746       {
4747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4748       };
4749     } catch (std::exception& e) {
4750       {
4751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4752       };
4753     } catch (Dali::DaliException e) {
4754       {
4755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4756       };
4757     } catch (...) {
4758       {
4759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4760       };
4761     }
4762   }
4763
4764   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4765   return jresult;
4766 }
4767
4768
4769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4770   void * jresult ;
4771   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4772   float arg2 ;
4773   Dali::Vector2 result;
4774
4775   arg1 = (Dali::Vector2 *)jarg1;
4776   arg2 = (float)jarg2;
4777   {
4778     try {
4779       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4780     } catch (std::out_of_range& e) {
4781       {
4782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4783       };
4784     } catch (std::exception& e) {
4785       {
4786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4787       };
4788     } catch (Dali::DaliException e) {
4789       {
4790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4791       };
4792     } catch (...) {
4793       {
4794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4795       };
4796     }
4797   }
4798
4799   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4800   return jresult;
4801 }
4802
4803
4804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4805   void * jresult ;
4806   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4807   Dali::Vector2 *arg2 = 0 ;
4808   Dali::Vector2 *result = 0 ;
4809
4810   arg1 = (Dali::Vector2 *)jarg1;
4811   arg2 = (Dali::Vector2 *)jarg2;
4812   if (!arg2) {
4813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4814     return 0;
4815   }
4816   {
4817     try {
4818       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4819     } catch (std::out_of_range& e) {
4820       {
4821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4822       };
4823     } catch (std::exception& e) {
4824       {
4825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4826       };
4827     } catch (Dali::DaliException e) {
4828       {
4829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4830       };
4831     } catch (...) {
4832       {
4833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4834       };
4835     }
4836   }
4837
4838   jresult = (void *)result;
4839   return jresult;
4840 }
4841
4842
4843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4844   void * jresult ;
4845   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4846   float arg2 ;
4847   Dali::Vector2 *result = 0 ;
4848
4849   arg1 = (Dali::Vector2 *)jarg1;
4850   arg2 = (float)jarg2;
4851   {
4852     try {
4853       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4854     } catch (std::out_of_range& e) {
4855       {
4856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4857       };
4858     } catch (std::exception& e) {
4859       {
4860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4861       };
4862     } catch (Dali::DaliException e) {
4863       {
4864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4865       };
4866     } catch (...) {
4867       {
4868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4869       };
4870     }
4871   }
4872
4873   jresult = (void *)result;
4874   return jresult;
4875 }
4876
4877
4878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4879   void * jresult ;
4880   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4881   Dali::Vector2 *arg2 = 0 ;
4882   Dali::Vector2 result;
4883
4884   arg1 = (Dali::Vector2 *)jarg1;
4885   arg2 = (Dali::Vector2 *)jarg2;
4886   if (!arg2) {
4887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4888     return 0;
4889   }
4890   {
4891     try {
4892       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4893     } catch (std::out_of_range& e) {
4894       {
4895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4896       };
4897     } catch (std::exception& e) {
4898       {
4899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4900       };
4901     } catch (Dali::DaliException e) {
4902       {
4903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4904       };
4905     } catch (...) {
4906       {
4907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4908       };
4909     }
4910   }
4911
4912   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4913   return jresult;
4914 }
4915
4916
4917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4918   void * jresult ;
4919   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4920   float arg2 ;
4921   Dali::Vector2 result;
4922
4923   arg1 = (Dali::Vector2 *)jarg1;
4924   arg2 = (float)jarg2;
4925   {
4926     try {
4927       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4928     } catch (std::out_of_range& e) {
4929       {
4930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4931       };
4932     } catch (std::exception& e) {
4933       {
4934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4935       };
4936     } catch (Dali::DaliException e) {
4937       {
4938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4939       };
4940     } catch (...) {
4941       {
4942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4943       };
4944     }
4945   }
4946
4947   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4948   return jresult;
4949 }
4950
4951
4952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4953   void * jresult ;
4954   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4955   Dali::Vector2 *arg2 = 0 ;
4956   Dali::Vector2 *result = 0 ;
4957
4958   arg1 = (Dali::Vector2 *)jarg1;
4959   arg2 = (Dali::Vector2 *)jarg2;
4960   if (!arg2) {
4961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4962     return 0;
4963   }
4964   {
4965     try {
4966       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4967     } catch (std::out_of_range& e) {
4968       {
4969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4970       };
4971     } catch (std::exception& e) {
4972       {
4973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4974       };
4975     } catch (Dali::DaliException e) {
4976       {
4977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4978       };
4979     } catch (...) {
4980       {
4981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4982       };
4983     }
4984   }
4985
4986   jresult = (void *)result;
4987   return jresult;
4988 }
4989
4990
4991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4992   void * jresult ;
4993   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4994   float arg2 ;
4995   Dali::Vector2 *result = 0 ;
4996
4997   arg1 = (Dali::Vector2 *)jarg1;
4998   arg2 = (float)jarg2;
4999   {
5000     try {
5001       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
5002     } catch (std::out_of_range& e) {
5003       {
5004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5005       };
5006     } catch (std::exception& e) {
5007       {
5008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5009       };
5010     } catch (Dali::DaliException e) {
5011       {
5012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5013       };
5014     } catch (...) {
5015       {
5016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5017       };
5018     }
5019   }
5020
5021   jresult = (void *)result;
5022   return jresult;
5023 }
5024
5025
5026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5027   void * jresult ;
5028   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5029   Dali::Vector2 result;
5030
5031   arg1 = (Dali::Vector2 *)jarg1;
5032   {
5033     try {
5034       result = ((Dali::Vector2 const *)arg1)->operator -();
5035     } catch (std::out_of_range& e) {
5036       {
5037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5038       };
5039     } catch (std::exception& e) {
5040       {
5041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5042       };
5043     } catch (Dali::DaliException e) {
5044       {
5045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5046       };
5047     } catch (...) {
5048       {
5049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5050       };
5051     }
5052   }
5053
5054   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5055   return jresult;
5056 }
5057
5058
5059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5060   unsigned int jresult ;
5061   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5062   Dali::Vector2 *arg2 = 0 ;
5063   bool result;
5064
5065   arg1 = (Dali::Vector2 *)jarg1;
5066   arg2 = (Dali::Vector2 *)jarg2;
5067   if (!arg2) {
5068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5069     return 0;
5070   }
5071   {
5072     try {
5073       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5074     } catch (std::out_of_range& e) {
5075       {
5076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5077       };
5078     } catch (std::exception& e) {
5079       {
5080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5081       };
5082     } catch (Dali::DaliException e) {
5083       {
5084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5085       };
5086     } catch (...) {
5087       {
5088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5089       };
5090     }
5091   }
5092
5093   jresult = result;
5094   return jresult;
5095 }
5096
5097
5098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5099   unsigned int jresult ;
5100   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5101   Dali::Vector2 *arg2 = 0 ;
5102   bool result;
5103
5104   arg1 = (Dali::Vector2 *)jarg1;
5105   arg2 = (Dali::Vector2 *)jarg2;
5106   if (!arg2) {
5107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5108     return 0;
5109   }
5110   {
5111     try {
5112       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5113     } catch (std::out_of_range& e) {
5114       {
5115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5116       };
5117     } catch (std::exception& e) {
5118       {
5119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5120       };
5121     } catch (Dali::DaliException e) {
5122       {
5123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5124       };
5125     } catch (...) {
5126       {
5127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5128       };
5129     }
5130   }
5131
5132   jresult = result;
5133   return jresult;
5134 }
5135
5136
5137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5138   float jresult ;
5139   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5140   unsigned int arg2 ;
5141   float *result = 0 ;
5142
5143   arg1 = (Dali::Vector2 *)jarg1;
5144   arg2 = (unsigned int)jarg2;
5145   {
5146     try {
5147       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5148     } catch (std::out_of_range& e) {
5149       {
5150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5151       };
5152     } catch (std::exception& e) {
5153       {
5154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5155       };
5156     } catch (Dali::DaliException e) {
5157       {
5158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5159       };
5160     } catch (...) {
5161       {
5162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5163       };
5164     }
5165   }
5166
5167   jresult = *result;
5168   return jresult;
5169 }
5170
5171
5172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5173   float jresult ;
5174   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5175   float result;
5176
5177   arg1 = (Dali::Vector2 *)jarg1;
5178   {
5179     try {
5180       result = (float)((Dali::Vector2 const *)arg1)->Length();
5181     } catch (std::out_of_range& e) {
5182       {
5183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5184       };
5185     } catch (std::exception& e) {
5186       {
5187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5188       };
5189     } catch (Dali::DaliException e) {
5190       {
5191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5192       };
5193     } catch (...) {
5194       {
5195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5196       };
5197     }
5198   }
5199
5200   jresult = result;
5201   return jresult;
5202 }
5203
5204
5205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5206   float jresult ;
5207   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5208   float result;
5209
5210   arg1 = (Dali::Vector2 *)jarg1;
5211   {
5212     try {
5213       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5214     } catch (std::out_of_range& e) {
5215       {
5216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5217       };
5218     } catch (std::exception& e) {
5219       {
5220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5221       };
5222     } catch (Dali::DaliException e) {
5223       {
5224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5225       };
5226     } catch (...) {
5227       {
5228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5229       };
5230     }
5231   }
5232
5233   jresult = result;
5234   return jresult;
5235 }
5236
5237
5238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5239   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5240
5241   arg1 = (Dali::Vector2 *)jarg1;
5242   {
5243     try {
5244       (arg1)->Normalize();
5245     } catch (std::out_of_range& e) {
5246       {
5247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5248       };
5249     } catch (std::exception& e) {
5250       {
5251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5252       };
5253     } catch (Dali::DaliException e) {
5254       {
5255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5256       };
5257     } catch (...) {
5258       {
5259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5260       };
5261     }
5262   }
5263
5264 }
5265
5266
5267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5268   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5269   Dali::Vector2 *arg2 = 0 ;
5270   Dali::Vector2 *arg3 = 0 ;
5271
5272   arg1 = (Dali::Vector2 *)jarg1;
5273   arg2 = (Dali::Vector2 *)jarg2;
5274   if (!arg2) {
5275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5276     return ;
5277   }
5278   arg3 = (Dali::Vector2 *)jarg3;
5279   if (!arg3) {
5280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5281     return ;
5282   }
5283   {
5284     try {
5285       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5286     } catch (std::out_of_range& e) {
5287       {
5288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5289       };
5290     } catch (std::exception& e) {
5291       {
5292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5293       };
5294     } catch (Dali::DaliException e) {
5295       {
5296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5297       };
5298     } catch (...) {
5299       {
5300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5301       };
5302     }
5303   }
5304
5305 }
5306
5307
5308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5309   void * jresult ;
5310   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5311   float *result = 0 ;
5312
5313   arg1 = (Dali::Vector2 *)jarg1;
5314   {
5315     try {
5316       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5317     } catch (std::out_of_range& e) {
5318       {
5319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5320       };
5321     } catch (std::exception& e) {
5322       {
5323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5324       };
5325     } catch (Dali::DaliException e) {
5326       {
5327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5328       };
5329     } catch (...) {
5330       {
5331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5332       };
5333     }
5334   }
5335
5336   jresult = (void *)result;
5337   return jresult;
5338 }
5339
5340
5341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5342   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5343   float arg2 ;
5344
5345   arg1 = (Dali::Vector2 *)jarg1;
5346   arg2 = (float)jarg2;
5347   if (arg1) (arg1)->x = arg2;
5348 }
5349
5350
5351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5352   float jresult ;
5353   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5354   float result;
5355
5356   arg1 = (Dali::Vector2 *)jarg1;
5357   result = (float) ((arg1)->x);
5358   jresult = result;
5359   return jresult;
5360 }
5361
5362
5363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5364   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5365   float arg2 ;
5366
5367   arg1 = (Dali::Vector2 *)jarg1;
5368   arg2 = (float)jarg2;
5369   if (arg1) (arg1)->width = arg2;
5370 }
5371
5372
5373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5374   float jresult ;
5375   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5376   float result;
5377
5378   arg1 = (Dali::Vector2 *)jarg1;
5379   result = (float) ((arg1)->width);
5380   jresult = result;
5381   return jresult;
5382 }
5383
5384
5385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5386   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5387   float arg2 ;
5388
5389   arg1 = (Dali::Vector2 *)jarg1;
5390   arg2 = (float)jarg2;
5391   if (arg1) (arg1)->y = arg2;
5392 }
5393
5394
5395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5396   float jresult ;
5397   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5398   float result;
5399
5400   arg1 = (Dali::Vector2 *)jarg1;
5401   result = (float) ((arg1)->y);
5402   jresult = result;
5403   return jresult;
5404 }
5405
5406
5407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5408   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5409   float arg2 ;
5410
5411   arg1 = (Dali::Vector2 *)jarg1;
5412   arg2 = (float)jarg2;
5413   if (arg1) (arg1)->height = arg2;
5414 }
5415
5416
5417 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5418   float jresult ;
5419   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5420   float result;
5421
5422   arg1 = (Dali::Vector2 *)jarg1;
5423   result = (float) ((arg1)->height);
5424   jresult = result;
5425   return jresult;
5426 }
5427
5428
5429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5430   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5431
5432   arg1 = (Dali::Vector2 *)jarg1;
5433   {
5434     try {
5435       delete arg1;
5436     } catch (std::out_of_range& e) {
5437       {
5438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5439       };
5440     } catch (std::exception& e) {
5441       {
5442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5443       };
5444     } catch (Dali::DaliException e) {
5445       {
5446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5447       };
5448     } catch (...) {
5449       {
5450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5451       };
5452     }
5453   }
5454
5455 }
5456
5457
5458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5459   void * jresult ;
5460   Dali::Vector2 *arg1 = 0 ;
5461   Dali::Vector2 *arg2 = 0 ;
5462   Dali::Vector2 result;
5463
5464   arg1 = (Dali::Vector2 *)jarg1;
5465   if (!arg1) {
5466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5467     return 0;
5468   }
5469   arg2 = (Dali::Vector2 *)jarg2;
5470   if (!arg2) {
5471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5472     return 0;
5473   }
5474   {
5475     try {
5476       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5477     } catch (std::out_of_range& e) {
5478       {
5479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5480       };
5481     } catch (std::exception& e) {
5482       {
5483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5484       };
5485     } catch (Dali::DaliException e) {
5486       {
5487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5488       };
5489     } catch (...) {
5490       {
5491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5492       };
5493     }
5494   }
5495
5496   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5497   return jresult;
5498 }
5499
5500
5501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5502   void * jresult ;
5503   Dali::Vector2 *arg1 = 0 ;
5504   Dali::Vector2 *arg2 = 0 ;
5505   Dali::Vector2 result;
5506
5507   arg1 = (Dali::Vector2 *)jarg1;
5508   if (!arg1) {
5509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5510     return 0;
5511   }
5512   arg2 = (Dali::Vector2 *)jarg2;
5513   if (!arg2) {
5514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5515     return 0;
5516   }
5517   {
5518     try {
5519       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5520     } catch (std::out_of_range& e) {
5521       {
5522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5523       };
5524     } catch (std::exception& e) {
5525       {
5526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5527       };
5528     } catch (Dali::DaliException e) {
5529       {
5530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5531       };
5532     } catch (...) {
5533       {
5534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5535       };
5536     }
5537   }
5538
5539   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5540   return jresult;
5541 }
5542
5543
5544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5545   void * jresult ;
5546   Dali::Vector2 *arg1 = 0 ;
5547   float *arg2 = 0 ;
5548   float *arg3 = 0 ;
5549   float temp2 ;
5550   float temp3 ;
5551   Dali::Vector2 result;
5552
5553   arg1 = (Dali::Vector2 *)jarg1;
5554   if (!arg1) {
5555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5556     return 0;
5557   }
5558   temp2 = (float)jarg2;
5559   arg2 = &temp2;
5560   temp3 = (float)jarg3;
5561   arg3 = &temp3;
5562   {
5563     try {
5564       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5565     } catch (std::out_of_range& e) {
5566       {
5567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5568       };
5569     } catch (std::exception& e) {
5570       {
5571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5572       };
5573     } catch (Dali::DaliException e) {
5574       {
5575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5576       };
5577     } catch (...) {
5578       {
5579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5580       };
5581     }
5582   }
5583
5584   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5585   return jresult;
5586 }
5587
5588
5589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5590   void * jresult ;
5591   Dali::Vector3 *result = 0 ;
5592
5593   {
5594     try {
5595       result = (Dali::Vector3 *)new Dali::Vector3();
5596     } catch (std::out_of_range& e) {
5597       {
5598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5599       };
5600     } catch (std::exception& e) {
5601       {
5602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5603       };
5604     } catch (Dali::DaliException e) {
5605       {
5606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5607       };
5608     } catch (...) {
5609       {
5610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5611       };
5612     }
5613   }
5614
5615   jresult = (void *)result;
5616   return jresult;
5617 }
5618
5619
5620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5621   void * jresult ;
5622   float arg1 ;
5623   float arg2 ;
5624   float arg3 ;
5625   Dali::Vector3 *result = 0 ;
5626
5627   arg1 = (float)jarg1;
5628   arg2 = (float)jarg2;
5629   arg3 = (float)jarg3;
5630   {
5631     try {
5632       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5633     } catch (std::out_of_range& e) {
5634       {
5635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5636       };
5637     } catch (std::exception& e) {
5638       {
5639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5640       };
5641     } catch (Dali::DaliException e) {
5642       {
5643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5644       };
5645     } catch (...) {
5646       {
5647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5648       };
5649     }
5650   }
5651
5652   jresult = (void *)result;
5653   return jresult;
5654 }
5655
5656
5657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5658   void * jresult ;
5659   float *arg1 = (float *) 0 ;
5660   Dali::Vector3 *result = 0 ;
5661
5662   arg1 = jarg1;
5663   {
5664     try {
5665       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5666     } catch (std::out_of_range& e) {
5667       {
5668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5669       };
5670     } catch (std::exception& e) {
5671       {
5672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5673       };
5674     } catch (Dali::DaliException e) {
5675       {
5676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5677       };
5678     } catch (...) {
5679       {
5680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5681       };
5682     }
5683   }
5684
5685   jresult = (void *)result;
5686
5687
5688   return jresult;
5689 }
5690
5691
5692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5693   void * jresult ;
5694   Dali::Vector2 *arg1 = 0 ;
5695   Dali::Vector3 *result = 0 ;
5696
5697   arg1 = (Dali::Vector2 *)jarg1;
5698   if (!arg1) {
5699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5700     return 0;
5701   }
5702   {
5703     try {
5704       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5705     } catch (std::out_of_range& e) {
5706       {
5707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5708       };
5709     } catch (std::exception& e) {
5710       {
5711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5712       };
5713     } catch (Dali::DaliException e) {
5714       {
5715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5716       };
5717     } catch (...) {
5718       {
5719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5720       };
5721     }
5722   }
5723
5724   jresult = (void *)result;
5725   return jresult;
5726 }
5727
5728
5729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5730   void * jresult ;
5731   Dali::Vector4 *arg1 = 0 ;
5732   Dali::Vector3 *result = 0 ;
5733
5734   arg1 = (Dali::Vector4 *)jarg1;
5735   if (!arg1) {
5736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5737     return 0;
5738   }
5739   {
5740     try {
5741       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5742     } catch (std::out_of_range& e) {
5743       {
5744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5745       };
5746     } catch (std::exception& e) {
5747       {
5748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5749       };
5750     } catch (Dali::DaliException e) {
5751       {
5752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5753       };
5754     } catch (...) {
5755       {
5756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5757       };
5758     }
5759   }
5760
5761   jresult = (void *)result;
5762   return jresult;
5763 }
5764
5765
5766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5767   void * jresult ;
5768   Dali::Vector3 *result = 0 ;
5769
5770   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5771   jresult = (void *)result;
5772   return jresult;
5773 }
5774
5775
5776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5777   void * jresult ;
5778   Dali::Vector3 *result = 0 ;
5779
5780   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5781   jresult = (void *)result;
5782   return jresult;
5783 }
5784
5785
5786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5787   void * jresult ;
5788   Dali::Vector3 *result = 0 ;
5789
5790   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5791   jresult = (void *)result;
5792   return jresult;
5793 }
5794
5795
5796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5797   void * jresult ;
5798   Dali::Vector3 *result = 0 ;
5799
5800   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5801   jresult = (void *)result;
5802   return jresult;
5803 }
5804
5805
5806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5807   void * jresult ;
5808   Dali::Vector3 *result = 0 ;
5809
5810   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5811   jresult = (void *)result;
5812   return jresult;
5813 }
5814
5815
5816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5817   void * jresult ;
5818   Dali::Vector3 *result = 0 ;
5819
5820   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5821   jresult = (void *)result;
5822   return jresult;
5823 }
5824
5825
5826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5827   void * jresult ;
5828   Dali::Vector3 *result = 0 ;
5829
5830   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5831   jresult = (void *)result;
5832   return jresult;
5833 }
5834
5835
5836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5837   void * jresult ;
5838   Dali::Vector3 *result = 0 ;
5839
5840   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5841   jresult = (void *)result;
5842   return jresult;
5843 }
5844
5845
5846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5847   void * jresult ;
5848   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5849   float *arg2 = (float *) 0 ;
5850   Dali::Vector3 *result = 0 ;
5851
5852   arg1 = (Dali::Vector3 *)jarg1;
5853   arg2 = jarg2;
5854   {
5855     try {
5856       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5857     } catch (std::out_of_range& e) {
5858       {
5859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5860       };
5861     } catch (std::exception& e) {
5862       {
5863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5864       };
5865     } catch (Dali::DaliException e) {
5866       {
5867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5868       };
5869     } catch (...) {
5870       {
5871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5872       };
5873     }
5874   }
5875
5876   jresult = (void *)result;
5877
5878
5879   return jresult;
5880 }
5881
5882
5883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5884   void * jresult ;
5885   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5886   Dali::Vector2 *arg2 = 0 ;
5887   Dali::Vector3 *result = 0 ;
5888
5889   arg1 = (Dali::Vector3 *)jarg1;
5890   arg2 = (Dali::Vector2 *)jarg2;
5891   if (!arg2) {
5892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5893     return 0;
5894   }
5895   {
5896     try {
5897       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5898     } catch (std::out_of_range& e) {
5899       {
5900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5901       };
5902     } catch (std::exception& e) {
5903       {
5904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5905       };
5906     } catch (Dali::DaliException e) {
5907       {
5908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5909       };
5910     } catch (...) {
5911       {
5912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5913       };
5914     }
5915   }
5916
5917   jresult = (void *)result;
5918   return jresult;
5919 }
5920
5921
5922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5923   void * jresult ;
5924   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5925   Dali::Vector4 *arg2 = 0 ;
5926   Dali::Vector3 *result = 0 ;
5927
5928   arg1 = (Dali::Vector3 *)jarg1;
5929   arg2 = (Dali::Vector4 *)jarg2;
5930   if (!arg2) {
5931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5932     return 0;
5933   }
5934   {
5935     try {
5936       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5937     } catch (std::out_of_range& e) {
5938       {
5939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5940       };
5941     } catch (std::exception& e) {
5942       {
5943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5944       };
5945     } catch (Dali::DaliException e) {
5946       {
5947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5948       };
5949     } catch (...) {
5950       {
5951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5952       };
5953     }
5954   }
5955
5956   jresult = (void *)result;
5957   return jresult;
5958 }
5959
5960
5961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5962   void * jresult ;
5963   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5964   Dali::Vector3 *arg2 = 0 ;
5965   Dali::Vector3 result;
5966
5967   arg1 = (Dali::Vector3 *)jarg1;
5968   arg2 = (Dali::Vector3 *)jarg2;
5969   if (!arg2) {
5970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5971     return 0;
5972   }
5973   {
5974     try {
5975       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5976     } catch (std::out_of_range& e) {
5977       {
5978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5979       };
5980     } catch (std::exception& e) {
5981       {
5982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5983       };
5984     } catch (Dali::DaliException e) {
5985       {
5986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5987       };
5988     } catch (...) {
5989       {
5990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5991       };
5992     }
5993   }
5994
5995   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5996   return jresult;
5997 }
5998
5999
6000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
6001   void * jresult ;
6002   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6003   Dali::Vector3 *arg2 = 0 ;
6004   Dali::Vector3 *result = 0 ;
6005
6006   arg1 = (Dali::Vector3 *)jarg1;
6007   arg2 = (Dali::Vector3 *)jarg2;
6008   if (!arg2) {
6009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6010     return 0;
6011   }
6012   {
6013     try {
6014       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6015     } catch (std::out_of_range& e) {
6016       {
6017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6018       };
6019     } catch (std::exception& e) {
6020       {
6021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6022       };
6023     } catch (Dali::DaliException e) {
6024       {
6025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6026       };
6027     } catch (...) {
6028       {
6029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6030       };
6031     }
6032   }
6033
6034   jresult = (void *)result;
6035   return jresult;
6036 }
6037
6038
6039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6040   void * jresult ;
6041   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6042   Dali::Vector3 *arg2 = 0 ;
6043   Dali::Vector3 result;
6044
6045   arg1 = (Dali::Vector3 *)jarg1;
6046   arg2 = (Dali::Vector3 *)jarg2;
6047   if (!arg2) {
6048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6049     return 0;
6050   }
6051   {
6052     try {
6053       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6054     } catch (std::out_of_range& e) {
6055       {
6056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6057       };
6058     } catch (std::exception& e) {
6059       {
6060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6061       };
6062     } catch (Dali::DaliException e) {
6063       {
6064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6065       };
6066     } catch (...) {
6067       {
6068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6069       };
6070     }
6071   }
6072
6073   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6074   return jresult;
6075 }
6076
6077
6078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6079   void * jresult ;
6080   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6081   Dali::Vector3 *arg2 = 0 ;
6082   Dali::Vector3 *result = 0 ;
6083
6084   arg1 = (Dali::Vector3 *)jarg1;
6085   arg2 = (Dali::Vector3 *)jarg2;
6086   if (!arg2) {
6087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6088     return 0;
6089   }
6090   {
6091     try {
6092       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6093     } catch (std::out_of_range& e) {
6094       {
6095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6096       };
6097     } catch (std::exception& e) {
6098       {
6099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6100       };
6101     } catch (Dali::DaliException e) {
6102       {
6103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6104       };
6105     } catch (...) {
6106       {
6107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6108       };
6109     }
6110   }
6111
6112   jresult = (void *)result;
6113   return jresult;
6114 }
6115
6116
6117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6118   void * jresult ;
6119   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6120   Dali::Vector3 *arg2 = 0 ;
6121   Dali::Vector3 result;
6122
6123   arg1 = (Dali::Vector3 *)jarg1;
6124   arg2 = (Dali::Vector3 *)jarg2;
6125   if (!arg2) {
6126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6127     return 0;
6128   }
6129   {
6130     try {
6131       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6132     } catch (std::out_of_range& e) {
6133       {
6134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6135       };
6136     } catch (std::exception& e) {
6137       {
6138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6139       };
6140     } catch (Dali::DaliException e) {
6141       {
6142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6143       };
6144     } catch (...) {
6145       {
6146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6147       };
6148     }
6149   }
6150
6151   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6152   return jresult;
6153 }
6154
6155
6156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6157   void * jresult ;
6158   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6159   float arg2 ;
6160   Dali::Vector3 result;
6161
6162   arg1 = (Dali::Vector3 *)jarg1;
6163   arg2 = (float)jarg2;
6164   {
6165     try {
6166       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6167     } catch (std::out_of_range& e) {
6168       {
6169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6170       };
6171     } catch (std::exception& e) {
6172       {
6173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6174       };
6175     } catch (Dali::DaliException e) {
6176       {
6177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6178       };
6179     } catch (...) {
6180       {
6181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6182       };
6183     }
6184   }
6185
6186   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6187   return jresult;
6188 }
6189
6190
6191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6192   void * jresult ;
6193   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6194   Dali::Vector3 *arg2 = 0 ;
6195   Dali::Vector3 *result = 0 ;
6196
6197   arg1 = (Dali::Vector3 *)jarg1;
6198   arg2 = (Dali::Vector3 *)jarg2;
6199   if (!arg2) {
6200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6201     return 0;
6202   }
6203   {
6204     try {
6205       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6206     } catch (std::out_of_range& e) {
6207       {
6208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6209       };
6210     } catch (std::exception& e) {
6211       {
6212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6213       };
6214     } catch (Dali::DaliException e) {
6215       {
6216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6217       };
6218     } catch (...) {
6219       {
6220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6221       };
6222     }
6223   }
6224
6225   jresult = (void *)result;
6226   return jresult;
6227 }
6228
6229
6230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6231   void * jresult ;
6232   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6233   float arg2 ;
6234   Dali::Vector3 *result = 0 ;
6235
6236   arg1 = (Dali::Vector3 *)jarg1;
6237   arg2 = (float)jarg2;
6238   {
6239     try {
6240       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6241     } catch (std::out_of_range& e) {
6242       {
6243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6244       };
6245     } catch (std::exception& e) {
6246       {
6247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6248       };
6249     } catch (Dali::DaliException e) {
6250       {
6251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6252       };
6253     } catch (...) {
6254       {
6255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6256       };
6257     }
6258   }
6259
6260   jresult = (void *)result;
6261   return jresult;
6262 }
6263
6264
6265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6266   void * jresult ;
6267   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6268   Dali::Quaternion *arg2 = 0 ;
6269   Dali::Vector3 *result = 0 ;
6270
6271   arg1 = (Dali::Vector3 *)jarg1;
6272   arg2 = (Dali::Quaternion *)jarg2;
6273   if (!arg2) {
6274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6275     return 0;
6276   }
6277   {
6278     try {
6279       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6280     } catch (std::out_of_range& e) {
6281       {
6282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6283       };
6284     } catch (std::exception& e) {
6285       {
6286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6287       };
6288     } catch (Dali::DaliException e) {
6289       {
6290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6291       };
6292     } catch (...) {
6293       {
6294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6295       };
6296     }
6297   }
6298
6299   jresult = (void *)result;
6300   return jresult;
6301 }
6302
6303
6304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6305   void * jresult ;
6306   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6307   Dali::Vector3 *arg2 = 0 ;
6308   Dali::Vector3 result;
6309
6310   arg1 = (Dali::Vector3 *)jarg1;
6311   arg2 = (Dali::Vector3 *)jarg2;
6312   if (!arg2) {
6313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6314     return 0;
6315   }
6316   {
6317     try {
6318       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6319     } catch (std::out_of_range& e) {
6320       {
6321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6322       };
6323     } catch (std::exception& e) {
6324       {
6325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6326       };
6327     } catch (Dali::DaliException e) {
6328       {
6329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6330       };
6331     } catch (...) {
6332       {
6333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6334       };
6335     }
6336   }
6337
6338   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6339   return jresult;
6340 }
6341
6342
6343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6344   void * jresult ;
6345   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6346   float arg2 ;
6347   Dali::Vector3 result;
6348
6349   arg1 = (Dali::Vector3 *)jarg1;
6350   arg2 = (float)jarg2;
6351   {
6352     try {
6353       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6354     } catch (std::out_of_range& e) {
6355       {
6356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6357       };
6358     } catch (std::exception& e) {
6359       {
6360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6361       };
6362     } catch (Dali::DaliException e) {
6363       {
6364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6365       };
6366     } catch (...) {
6367       {
6368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6369       };
6370     }
6371   }
6372
6373   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6374   return jresult;
6375 }
6376
6377
6378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6379   void * jresult ;
6380   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6381   Dali::Vector3 *arg2 = 0 ;
6382   Dali::Vector3 *result = 0 ;
6383
6384   arg1 = (Dali::Vector3 *)jarg1;
6385   arg2 = (Dali::Vector3 *)jarg2;
6386   if (!arg2) {
6387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6388     return 0;
6389   }
6390   {
6391     try {
6392       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6393     } catch (std::out_of_range& e) {
6394       {
6395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6396       };
6397     } catch (std::exception& e) {
6398       {
6399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6400       };
6401     } catch (Dali::DaliException e) {
6402       {
6403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6404       };
6405     } catch (...) {
6406       {
6407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6408       };
6409     }
6410   }
6411
6412   jresult = (void *)result;
6413   return jresult;
6414 }
6415
6416
6417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6418   void * jresult ;
6419   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6420   float arg2 ;
6421   Dali::Vector3 *result = 0 ;
6422
6423   arg1 = (Dali::Vector3 *)jarg1;
6424   arg2 = (float)jarg2;
6425   {
6426     try {
6427       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6428     } catch (std::out_of_range& e) {
6429       {
6430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6431       };
6432     } catch (std::exception& e) {
6433       {
6434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6435       };
6436     } catch (Dali::DaliException e) {
6437       {
6438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6439       };
6440     } catch (...) {
6441       {
6442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6443       };
6444     }
6445   }
6446
6447   jresult = (void *)result;
6448   return jresult;
6449 }
6450
6451
6452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6453   void * jresult ;
6454   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6455   Dali::Vector3 result;
6456
6457   arg1 = (Dali::Vector3 *)jarg1;
6458   {
6459     try {
6460       result = ((Dali::Vector3 const *)arg1)->operator -();
6461     } catch (std::out_of_range& e) {
6462       {
6463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6464       };
6465     } catch (std::exception& e) {
6466       {
6467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6468       };
6469     } catch (Dali::DaliException e) {
6470       {
6471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6472       };
6473     } catch (...) {
6474       {
6475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6476       };
6477     }
6478   }
6479
6480   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6481   return jresult;
6482 }
6483
6484
6485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6486   unsigned int jresult ;
6487   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6488   Dali::Vector3 *arg2 = 0 ;
6489   bool result;
6490
6491   arg1 = (Dali::Vector3 *)jarg1;
6492   arg2 = (Dali::Vector3 *)jarg2;
6493   if (!arg2) {
6494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6495     return 0;
6496   }
6497   {
6498     try {
6499       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6500     } catch (std::out_of_range& e) {
6501       {
6502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6503       };
6504     } catch (std::exception& e) {
6505       {
6506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6507       };
6508     } catch (Dali::DaliException e) {
6509       {
6510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6511       };
6512     } catch (...) {
6513       {
6514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6515       };
6516     }
6517   }
6518
6519   jresult = result;
6520   return jresult;
6521 }
6522
6523
6524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6525   unsigned int jresult ;
6526   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6527   Dali::Vector3 *arg2 = 0 ;
6528   bool result;
6529
6530   arg1 = (Dali::Vector3 *)jarg1;
6531   arg2 = (Dali::Vector3 *)jarg2;
6532   if (!arg2) {
6533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6534     return 0;
6535   }
6536   {
6537     try {
6538       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6539     } catch (std::out_of_range& e) {
6540       {
6541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6542       };
6543     } catch (std::exception& e) {
6544       {
6545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6546       };
6547     } catch (Dali::DaliException e) {
6548       {
6549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6550       };
6551     } catch (...) {
6552       {
6553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6554       };
6555     }
6556   }
6557
6558   jresult = result;
6559   return jresult;
6560 }
6561
6562
6563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6564   float jresult ;
6565   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6566   unsigned int arg2 ;
6567   float *result = 0 ;
6568
6569   arg1 = (Dali::Vector3 *)jarg1;
6570   arg2 = (unsigned int)jarg2;
6571   {
6572     try {
6573       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6574     } catch (std::out_of_range& e) {
6575       {
6576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6577       };
6578     } catch (std::exception& e) {
6579       {
6580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6581       };
6582     } catch (Dali::DaliException e) {
6583       {
6584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6585       };
6586     } catch (...) {
6587       {
6588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6589       };
6590     }
6591   }
6592
6593   jresult = *result;
6594   return jresult;
6595 }
6596
6597
6598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6599   float jresult ;
6600   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6601   Dali::Vector3 *arg2 = 0 ;
6602   float result;
6603
6604   arg1 = (Dali::Vector3 *)jarg1;
6605   arg2 = (Dali::Vector3 *)jarg2;
6606   if (!arg2) {
6607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6608     return 0;
6609   }
6610   {
6611     try {
6612       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6613     } catch (std::out_of_range& e) {
6614       {
6615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6616       };
6617     } catch (std::exception& e) {
6618       {
6619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6620       };
6621     } catch (Dali::DaliException e) {
6622       {
6623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6624       };
6625     } catch (...) {
6626       {
6627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6628       };
6629     }
6630   }
6631
6632   jresult = result;
6633   return jresult;
6634 }
6635
6636
6637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6638   void * jresult ;
6639   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6640   Dali::Vector3 *arg2 = 0 ;
6641   Dali::Vector3 result;
6642
6643   arg1 = (Dali::Vector3 *)jarg1;
6644   arg2 = (Dali::Vector3 *)jarg2;
6645   if (!arg2) {
6646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6647     return 0;
6648   }
6649   {
6650     try {
6651       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6652     } catch (std::out_of_range& e) {
6653       {
6654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6655       };
6656     } catch (std::exception& e) {
6657       {
6658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6659       };
6660     } catch (Dali::DaliException e) {
6661       {
6662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6663       };
6664     } catch (...) {
6665       {
6666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6667       };
6668     }
6669   }
6670
6671   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6672   return jresult;
6673 }
6674
6675
6676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6677   float jresult ;
6678   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6679   float result;
6680
6681   arg1 = (Dali::Vector3 *)jarg1;
6682   {
6683     try {
6684       result = (float)((Dali::Vector3 const *)arg1)->Length();
6685     } catch (std::out_of_range& e) {
6686       {
6687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6688       };
6689     } catch (std::exception& e) {
6690       {
6691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6692       };
6693     } catch (Dali::DaliException e) {
6694       {
6695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6696       };
6697     } catch (...) {
6698       {
6699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6700       };
6701     }
6702   }
6703
6704   jresult = result;
6705   return jresult;
6706 }
6707
6708
6709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6710   float jresult ;
6711   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6712   float result;
6713
6714   arg1 = (Dali::Vector3 *)jarg1;
6715   {
6716     try {
6717       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6718     } catch (std::out_of_range& e) {
6719       {
6720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6721       };
6722     } catch (std::exception& e) {
6723       {
6724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6725       };
6726     } catch (Dali::DaliException e) {
6727       {
6728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6729       };
6730     } catch (...) {
6731       {
6732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6733       };
6734     }
6735   }
6736
6737   jresult = result;
6738   return jresult;
6739 }
6740
6741
6742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6743   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6744
6745   arg1 = (Dali::Vector3 *)jarg1;
6746   {
6747     try {
6748       (arg1)->Normalize();
6749     } catch (std::out_of_range& e) {
6750       {
6751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6752       };
6753     } catch (std::exception& e) {
6754       {
6755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6756       };
6757     } catch (Dali::DaliException e) {
6758       {
6759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6760       };
6761     } catch (...) {
6762       {
6763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6764       };
6765     }
6766   }
6767
6768 }
6769
6770
6771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6772   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6773   Dali::Vector3 *arg2 = 0 ;
6774   Dali::Vector3 *arg3 = 0 ;
6775
6776   arg1 = (Dali::Vector3 *)jarg1;
6777   arg2 = (Dali::Vector3 *)jarg2;
6778   if (!arg2) {
6779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6780     return ;
6781   }
6782   arg3 = (Dali::Vector3 *)jarg3;
6783   if (!arg3) {
6784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6785     return ;
6786   }
6787   {
6788     try {
6789       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6790     } catch (std::out_of_range& e) {
6791       {
6792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6793       };
6794     } catch (std::exception& e) {
6795       {
6796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6797       };
6798     } catch (Dali::DaliException e) {
6799       {
6800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6801       };
6802     } catch (...) {
6803       {
6804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6805       };
6806     }
6807   }
6808
6809 }
6810
6811
6812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6813   void * jresult ;
6814   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6815   float *result = 0 ;
6816
6817   arg1 = (Dali::Vector3 *)jarg1;
6818   {
6819     try {
6820       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6821     } catch (std::out_of_range& e) {
6822       {
6823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6824       };
6825     } catch (std::exception& e) {
6826       {
6827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6828       };
6829     } catch (Dali::DaliException e) {
6830       {
6831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6832       };
6833     } catch (...) {
6834       {
6835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6836       };
6837     }
6838   }
6839
6840   jresult = (void *)result;
6841   return jresult;
6842 }
6843
6844
6845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6846   void * jresult ;
6847   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6848   Dali::Vector2 *result = 0 ;
6849
6850   arg1 = (Dali::Vector3 *)jarg1;
6851   {
6852     try {
6853       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6854     } catch (std::out_of_range& e) {
6855       {
6856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6857       };
6858     } catch (std::exception& e) {
6859       {
6860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6861       };
6862     } catch (Dali::DaliException e) {
6863       {
6864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6865       };
6866     } catch (...) {
6867       {
6868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6869       };
6870     }
6871   }
6872
6873   jresult = (void *)result;
6874   return jresult;
6875 }
6876
6877
6878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6879   void * jresult ;
6880   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6881   Dali::Vector2 *result = 0 ;
6882
6883   arg1 = (Dali::Vector3 *)jarg1;
6884   {
6885     try {
6886       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6887     } catch (std::out_of_range& e) {
6888       {
6889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6890       };
6891     } catch (std::exception& e) {
6892       {
6893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6894       };
6895     } catch (Dali::DaliException e) {
6896       {
6897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6898       };
6899     } catch (...) {
6900       {
6901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6902       };
6903     }
6904   }
6905
6906   jresult = (void *)result;
6907   return jresult;
6908 }
6909
6910
6911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6912   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6913   float arg2 ;
6914
6915   arg1 = (Dali::Vector3 *)jarg1;
6916   arg2 = (float)jarg2;
6917   if (arg1) (arg1)->x = arg2;
6918 }
6919
6920
6921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6922   float jresult ;
6923   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6924   float result;
6925
6926   arg1 = (Dali::Vector3 *)jarg1;
6927   result = (float) ((arg1)->x);
6928   jresult = result;
6929   return jresult;
6930 }
6931
6932
6933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6934   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6935   float arg2 ;
6936
6937   arg1 = (Dali::Vector3 *)jarg1;
6938   arg2 = (float)jarg2;
6939   if (arg1) (arg1)->width = arg2;
6940 }
6941
6942
6943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6944   float jresult ;
6945   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6946   float result;
6947
6948   arg1 = (Dali::Vector3 *)jarg1;
6949   result = (float) ((arg1)->width);
6950   jresult = result;
6951   return jresult;
6952 }
6953
6954
6955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6956   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6957   float arg2 ;
6958
6959   arg1 = (Dali::Vector3 *)jarg1;
6960   arg2 = (float)jarg2;
6961   if (arg1) (arg1)->r = arg2;
6962 }
6963
6964
6965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6966   float jresult ;
6967   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6968   float result;
6969
6970   arg1 = (Dali::Vector3 *)jarg1;
6971   result = (float) ((arg1)->r);
6972   jresult = result;
6973   return jresult;
6974 }
6975
6976
6977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6978   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6979   float arg2 ;
6980
6981   arg1 = (Dali::Vector3 *)jarg1;
6982   arg2 = (float)jarg2;
6983   if (arg1) (arg1)->y = arg2;
6984 }
6985
6986
6987 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6988   float jresult ;
6989   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6990   float result;
6991
6992   arg1 = (Dali::Vector3 *)jarg1;
6993   result = (float) ((arg1)->y);
6994   jresult = result;
6995   return jresult;
6996 }
6997
6998
6999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
7000   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7001   float arg2 ;
7002
7003   arg1 = (Dali::Vector3 *)jarg1;
7004   arg2 = (float)jarg2;
7005   if (arg1) (arg1)->height = arg2;
7006 }
7007
7008
7009 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7010   float jresult ;
7011   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7012   float result;
7013
7014   arg1 = (Dali::Vector3 *)jarg1;
7015   result = (float) ((arg1)->height);
7016   jresult = result;
7017   return jresult;
7018 }
7019
7020
7021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7022   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7023   float arg2 ;
7024
7025   arg1 = (Dali::Vector3 *)jarg1;
7026   arg2 = (float)jarg2;
7027   if (arg1) (arg1)->g = arg2;
7028 }
7029
7030
7031 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7032   float jresult ;
7033   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7034   float result;
7035
7036   arg1 = (Dali::Vector3 *)jarg1;
7037   result = (float) ((arg1)->g);
7038   jresult = result;
7039   return jresult;
7040 }
7041
7042
7043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7044   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7045   float arg2 ;
7046
7047   arg1 = (Dali::Vector3 *)jarg1;
7048   arg2 = (float)jarg2;
7049   if (arg1) (arg1)->z = arg2;
7050 }
7051
7052
7053 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7054   float jresult ;
7055   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7056   float result;
7057
7058   arg1 = (Dali::Vector3 *)jarg1;
7059   result = (float) ((arg1)->z);
7060   jresult = result;
7061   return jresult;
7062 }
7063
7064
7065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7066   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7067   float arg2 ;
7068
7069   arg1 = (Dali::Vector3 *)jarg1;
7070   arg2 = (float)jarg2;
7071   if (arg1) (arg1)->depth = arg2;
7072 }
7073
7074
7075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7076   float jresult ;
7077   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7078   float result;
7079
7080   arg1 = (Dali::Vector3 *)jarg1;
7081   result = (float) ((arg1)->depth);
7082   jresult = result;
7083   return jresult;
7084 }
7085
7086
7087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7088   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7089   float arg2 ;
7090
7091   arg1 = (Dali::Vector3 *)jarg1;
7092   arg2 = (float)jarg2;
7093   if (arg1) (arg1)->b = arg2;
7094 }
7095
7096
7097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7098   float jresult ;
7099   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7100   float result;
7101
7102   arg1 = (Dali::Vector3 *)jarg1;
7103   result = (float) ((arg1)->b);
7104   jresult = result;
7105   return jresult;
7106 }
7107
7108
7109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7110   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7111
7112   arg1 = (Dali::Vector3 *)jarg1;
7113   {
7114     try {
7115       delete arg1;
7116     } catch (std::out_of_range& e) {
7117       {
7118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7119       };
7120     } catch (std::exception& e) {
7121       {
7122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7123       };
7124     } catch (Dali::DaliException e) {
7125       {
7126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7127       };
7128     } catch (...) {
7129       {
7130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7131       };
7132     }
7133   }
7134
7135 }
7136
7137
7138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7139   void * jresult ;
7140   Dali::Vector3 *arg1 = 0 ;
7141   Dali::Vector3 *arg2 = 0 ;
7142   Dali::Vector3 result;
7143
7144   arg1 = (Dali::Vector3 *)jarg1;
7145   if (!arg1) {
7146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7147     return 0;
7148   }
7149   arg2 = (Dali::Vector3 *)jarg2;
7150   if (!arg2) {
7151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7152     return 0;
7153   }
7154   {
7155     try {
7156       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7157     } catch (std::out_of_range& e) {
7158       {
7159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7160       };
7161     } catch (std::exception& e) {
7162       {
7163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7164       };
7165     } catch (Dali::DaliException e) {
7166       {
7167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7168       };
7169     } catch (...) {
7170       {
7171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7172       };
7173     }
7174   }
7175
7176   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7177   return jresult;
7178 }
7179
7180
7181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7182   void * jresult ;
7183   Dali::Vector3 *arg1 = 0 ;
7184   Dali::Vector3 *arg2 = 0 ;
7185   Dali::Vector3 result;
7186
7187   arg1 = (Dali::Vector3 *)jarg1;
7188   if (!arg1) {
7189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7190     return 0;
7191   }
7192   arg2 = (Dali::Vector3 *)jarg2;
7193   if (!arg2) {
7194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7195     return 0;
7196   }
7197   {
7198     try {
7199       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7200     } catch (std::out_of_range& e) {
7201       {
7202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7203       };
7204     } catch (std::exception& e) {
7205       {
7206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7207       };
7208     } catch (Dali::DaliException e) {
7209       {
7210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7211       };
7212     } catch (...) {
7213       {
7214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7215       };
7216     }
7217   }
7218
7219   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7220   return jresult;
7221 }
7222
7223
7224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7225   void * jresult ;
7226   Dali::Vector3 *arg1 = 0 ;
7227   float *arg2 = 0 ;
7228   float *arg3 = 0 ;
7229   float temp2 ;
7230   float temp3 ;
7231   Dali::Vector3 result;
7232
7233   arg1 = (Dali::Vector3 *)jarg1;
7234   if (!arg1) {
7235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7236     return 0;
7237   }
7238   temp2 = (float)jarg2;
7239   arg2 = &temp2;
7240   temp3 = (float)jarg3;
7241   arg3 = &temp3;
7242   {
7243     try {
7244       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7245     } catch (std::out_of_range& e) {
7246       {
7247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7248       };
7249     } catch (std::exception& e) {
7250       {
7251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7252       };
7253     } catch (Dali::DaliException e) {
7254       {
7255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7256       };
7257     } catch (...) {
7258       {
7259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7260       };
7261     }
7262   }
7263
7264   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7265   return jresult;
7266 }
7267
7268
7269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7270   void * jresult ;
7271   Dali::Vector4 *result = 0 ;
7272
7273   {
7274     try {
7275       result = (Dali::Vector4 *)new Dali::Vector4();
7276     } catch (std::out_of_range& e) {
7277       {
7278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7279       };
7280     } catch (std::exception& e) {
7281       {
7282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7283       };
7284     } catch (Dali::DaliException e) {
7285       {
7286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7287       };
7288     } catch (...) {
7289       {
7290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7291       };
7292     }
7293   }
7294
7295   jresult = (void *)result;
7296   return jresult;
7297 }
7298
7299
7300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7301   void * jresult ;
7302   float arg1 ;
7303   float arg2 ;
7304   float arg3 ;
7305   float arg4 ;
7306   Dali::Vector4 *result = 0 ;
7307
7308   arg1 = (float)jarg1;
7309   arg2 = (float)jarg2;
7310   arg3 = (float)jarg3;
7311   arg4 = (float)jarg4;
7312   {
7313     try {
7314       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7315     } catch (std::out_of_range& e) {
7316       {
7317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7318       };
7319     } catch (std::exception& e) {
7320       {
7321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7322       };
7323     } catch (Dali::DaliException e) {
7324       {
7325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7326       };
7327     } catch (...) {
7328       {
7329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7330       };
7331     }
7332   }
7333
7334   jresult = (void *)result;
7335   return jresult;
7336 }
7337
7338
7339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7340   void * jresult ;
7341   float *arg1 = (float *) 0 ;
7342   Dali::Vector4 *result = 0 ;
7343
7344   arg1 = jarg1;
7345   {
7346     try {
7347       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7348     } catch (std::out_of_range& e) {
7349       {
7350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7351       };
7352     } catch (std::exception& e) {
7353       {
7354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7355       };
7356     } catch (Dali::DaliException e) {
7357       {
7358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7359       };
7360     } catch (...) {
7361       {
7362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7363       };
7364     }
7365   }
7366
7367   jresult = (void *)result;
7368
7369
7370   return jresult;
7371 }
7372
7373
7374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7375   void * jresult ;
7376   Dali::Vector2 *arg1 = 0 ;
7377   Dali::Vector4 *result = 0 ;
7378
7379   arg1 = (Dali::Vector2 *)jarg1;
7380   if (!arg1) {
7381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7382     return 0;
7383   }
7384   {
7385     try {
7386       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7387     } catch (std::out_of_range& e) {
7388       {
7389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7390       };
7391     } catch (std::exception& e) {
7392       {
7393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7394       };
7395     } catch (Dali::DaliException e) {
7396       {
7397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7398       };
7399     } catch (...) {
7400       {
7401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7402       };
7403     }
7404   }
7405
7406   jresult = (void *)result;
7407   return jresult;
7408 }
7409
7410
7411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7412   void * jresult ;
7413   Dali::Vector3 *arg1 = 0 ;
7414   Dali::Vector4 *result = 0 ;
7415
7416   arg1 = (Dali::Vector3 *)jarg1;
7417   if (!arg1) {
7418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7419     return 0;
7420   }
7421   {
7422     try {
7423       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7424     } catch (std::out_of_range& e) {
7425       {
7426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7427       };
7428     } catch (std::exception& e) {
7429       {
7430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7431       };
7432     } catch (Dali::DaliException e) {
7433       {
7434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7435       };
7436     } catch (...) {
7437       {
7438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7439       };
7440     }
7441   }
7442
7443   jresult = (void *)result;
7444   return jresult;
7445 }
7446
7447
7448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7449   void * jresult ;
7450   Dali::Vector4 *result = 0 ;
7451
7452   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7453   jresult = (void *)result;
7454   return jresult;
7455 }
7456
7457
7458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7459   void * jresult ;
7460   Dali::Vector4 *result = 0 ;
7461
7462   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7463   jresult = (void *)result;
7464   return jresult;
7465 }
7466
7467
7468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7469   void * jresult ;
7470   Dali::Vector4 *result = 0 ;
7471
7472   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7473   jresult = (void *)result;
7474   return jresult;
7475 }
7476
7477
7478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7479   void * jresult ;
7480   Dali::Vector4 *result = 0 ;
7481
7482   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7483   jresult = (void *)result;
7484   return jresult;
7485 }
7486
7487
7488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7489   void * jresult ;
7490   Dali::Vector4 *result = 0 ;
7491
7492   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7493   jresult = (void *)result;
7494   return jresult;
7495 }
7496
7497
7498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7499   void * jresult ;
7500   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7501   float *arg2 = (float *) 0 ;
7502   Dali::Vector4 *result = 0 ;
7503
7504   arg1 = (Dali::Vector4 *)jarg1;
7505   arg2 = jarg2;
7506   {
7507     try {
7508       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7509     } catch (std::out_of_range& e) {
7510       {
7511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7512       };
7513     } catch (std::exception& e) {
7514       {
7515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7516       };
7517     } catch (Dali::DaliException e) {
7518       {
7519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7520       };
7521     } catch (...) {
7522       {
7523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7524       };
7525     }
7526   }
7527
7528   jresult = (void *)result;
7529
7530
7531   return jresult;
7532 }
7533
7534
7535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7536   void * jresult ;
7537   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7538   Dali::Vector2 *arg2 = 0 ;
7539   Dali::Vector4 *result = 0 ;
7540
7541   arg1 = (Dali::Vector4 *)jarg1;
7542   arg2 = (Dali::Vector2 *)jarg2;
7543   if (!arg2) {
7544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7545     return 0;
7546   }
7547   {
7548     try {
7549       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7550     } catch (std::out_of_range& e) {
7551       {
7552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7553       };
7554     } catch (std::exception& e) {
7555       {
7556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7557       };
7558     } catch (Dali::DaliException e) {
7559       {
7560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7561       };
7562     } catch (...) {
7563       {
7564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7565       };
7566     }
7567   }
7568
7569   jresult = (void *)result;
7570   return jresult;
7571 }
7572
7573
7574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7575   void * jresult ;
7576   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7577   Dali::Vector3 *arg2 = 0 ;
7578   Dali::Vector4 *result = 0 ;
7579
7580   arg1 = (Dali::Vector4 *)jarg1;
7581   arg2 = (Dali::Vector3 *)jarg2;
7582   if (!arg2) {
7583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7584     return 0;
7585   }
7586   {
7587     try {
7588       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7589     } catch (std::out_of_range& e) {
7590       {
7591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7592       };
7593     } catch (std::exception& e) {
7594       {
7595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7596       };
7597     } catch (Dali::DaliException e) {
7598       {
7599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7600       };
7601     } catch (...) {
7602       {
7603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7604       };
7605     }
7606   }
7607
7608   jresult = (void *)result;
7609   return jresult;
7610 }
7611
7612
7613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7614   void * jresult ;
7615   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7616   Dali::Vector4 *arg2 = 0 ;
7617   Dali::Vector4 result;
7618
7619   arg1 = (Dali::Vector4 *)jarg1;
7620   arg2 = (Dali::Vector4 *)jarg2;
7621   if (!arg2) {
7622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7623     return 0;
7624   }
7625   {
7626     try {
7627       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7628     } catch (std::out_of_range& e) {
7629       {
7630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7631       };
7632     } catch (std::exception& e) {
7633       {
7634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7635       };
7636     } catch (Dali::DaliException e) {
7637       {
7638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7639       };
7640     } catch (...) {
7641       {
7642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7643       };
7644     }
7645   }
7646
7647   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7648   return jresult;
7649 }
7650
7651
7652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7653   void * jresult ;
7654   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7655   Dali::Vector4 *arg2 = 0 ;
7656   Dali::Vector4 *result = 0 ;
7657
7658   arg1 = (Dali::Vector4 *)jarg1;
7659   arg2 = (Dali::Vector4 *)jarg2;
7660   if (!arg2) {
7661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7662     return 0;
7663   }
7664   {
7665     try {
7666       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7667     } catch (std::out_of_range& e) {
7668       {
7669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7670       };
7671     } catch (std::exception& e) {
7672       {
7673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7674       };
7675     } catch (Dali::DaliException e) {
7676       {
7677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7678       };
7679     } catch (...) {
7680       {
7681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7682       };
7683     }
7684   }
7685
7686   jresult = (void *)result;
7687   return jresult;
7688 }
7689
7690
7691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7692   void * jresult ;
7693   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7694   Dali::Vector4 *arg2 = 0 ;
7695   Dali::Vector4 result;
7696
7697   arg1 = (Dali::Vector4 *)jarg1;
7698   arg2 = (Dali::Vector4 *)jarg2;
7699   if (!arg2) {
7700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7701     return 0;
7702   }
7703   {
7704     try {
7705       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7706     } catch (std::out_of_range& e) {
7707       {
7708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7709       };
7710     } catch (std::exception& e) {
7711       {
7712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7713       };
7714     } catch (Dali::DaliException e) {
7715       {
7716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7717       };
7718     } catch (...) {
7719       {
7720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7721       };
7722     }
7723   }
7724
7725   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7726   return jresult;
7727 }
7728
7729
7730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7731   void * jresult ;
7732   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7733   Dali::Vector4 *arg2 = 0 ;
7734   Dali::Vector4 *result = 0 ;
7735
7736   arg1 = (Dali::Vector4 *)jarg1;
7737   arg2 = (Dali::Vector4 *)jarg2;
7738   if (!arg2) {
7739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7740     return 0;
7741   }
7742   {
7743     try {
7744       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7745     } catch (std::out_of_range& e) {
7746       {
7747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7748       };
7749     } catch (std::exception& e) {
7750       {
7751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7752       };
7753     } catch (Dali::DaliException e) {
7754       {
7755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7756       };
7757     } catch (...) {
7758       {
7759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7760       };
7761     }
7762   }
7763
7764   jresult = (void *)result;
7765   return jresult;
7766 }
7767
7768
7769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7770   void * jresult ;
7771   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7772   Dali::Vector4 *arg2 = 0 ;
7773   Dali::Vector4 result;
7774
7775   arg1 = (Dali::Vector4 *)jarg1;
7776   arg2 = (Dali::Vector4 *)jarg2;
7777   if (!arg2) {
7778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7779     return 0;
7780   }
7781   {
7782     try {
7783       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7784     } catch (std::out_of_range& e) {
7785       {
7786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7787       };
7788     } catch (std::exception& e) {
7789       {
7790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7791       };
7792     } catch (Dali::DaliException e) {
7793       {
7794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7795       };
7796     } catch (...) {
7797       {
7798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7799       };
7800     }
7801   }
7802
7803   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7804   return jresult;
7805 }
7806
7807
7808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7809   void * jresult ;
7810   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7811   float arg2 ;
7812   Dali::Vector4 result;
7813
7814   arg1 = (Dali::Vector4 *)jarg1;
7815   arg2 = (float)jarg2;
7816   {
7817     try {
7818       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7819     } catch (std::out_of_range& e) {
7820       {
7821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7822       };
7823     } catch (std::exception& e) {
7824       {
7825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7826       };
7827     } catch (Dali::DaliException e) {
7828       {
7829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7830       };
7831     } catch (...) {
7832       {
7833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7834       };
7835     }
7836   }
7837
7838   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7839   return jresult;
7840 }
7841
7842
7843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7844   void * jresult ;
7845   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7846   Dali::Vector4 *arg2 = 0 ;
7847   Dali::Vector4 *result = 0 ;
7848
7849   arg1 = (Dali::Vector4 *)jarg1;
7850   arg2 = (Dali::Vector4 *)jarg2;
7851   if (!arg2) {
7852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7853     return 0;
7854   }
7855   {
7856     try {
7857       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7858     } catch (std::out_of_range& e) {
7859       {
7860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7861       };
7862     } catch (std::exception& e) {
7863       {
7864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7865       };
7866     } catch (Dali::DaliException e) {
7867       {
7868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7869       };
7870     } catch (...) {
7871       {
7872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7873       };
7874     }
7875   }
7876
7877   jresult = (void *)result;
7878   return jresult;
7879 }
7880
7881
7882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7883   void * jresult ;
7884   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7885   float arg2 ;
7886   Dali::Vector4 *result = 0 ;
7887
7888   arg1 = (Dali::Vector4 *)jarg1;
7889   arg2 = (float)jarg2;
7890   {
7891     try {
7892       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7893     } catch (std::out_of_range& e) {
7894       {
7895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7896       };
7897     } catch (std::exception& e) {
7898       {
7899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7900       };
7901     } catch (Dali::DaliException e) {
7902       {
7903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7904       };
7905     } catch (...) {
7906       {
7907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7908       };
7909     }
7910   }
7911
7912   jresult = (void *)result;
7913   return jresult;
7914 }
7915
7916
7917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7918   void * jresult ;
7919   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7920   Dali::Vector4 *arg2 = 0 ;
7921   Dali::Vector4 result;
7922
7923   arg1 = (Dali::Vector4 *)jarg1;
7924   arg2 = (Dali::Vector4 *)jarg2;
7925   if (!arg2) {
7926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7927     return 0;
7928   }
7929   {
7930     try {
7931       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7932     } catch (std::out_of_range& e) {
7933       {
7934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7935       };
7936     } catch (std::exception& e) {
7937       {
7938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7939       };
7940     } catch (Dali::DaliException e) {
7941       {
7942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7943       };
7944     } catch (...) {
7945       {
7946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7947       };
7948     }
7949   }
7950
7951   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7952   return jresult;
7953 }
7954
7955
7956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7957   void * jresult ;
7958   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7959   float arg2 ;
7960   Dali::Vector4 result;
7961
7962   arg1 = (Dali::Vector4 *)jarg1;
7963   arg2 = (float)jarg2;
7964   {
7965     try {
7966       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7967     } catch (std::out_of_range& e) {
7968       {
7969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7970       };
7971     } catch (std::exception& e) {
7972       {
7973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7974       };
7975     } catch (Dali::DaliException e) {
7976       {
7977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7978       };
7979     } catch (...) {
7980       {
7981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7982       };
7983     }
7984   }
7985
7986   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7987   return jresult;
7988 }
7989
7990
7991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7992   void * jresult ;
7993   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7994   Dali::Vector4 *arg2 = 0 ;
7995   Dali::Vector4 *result = 0 ;
7996
7997   arg1 = (Dali::Vector4 *)jarg1;
7998   arg2 = (Dali::Vector4 *)jarg2;
7999   if (!arg2) {
8000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8001     return 0;
8002   }
8003   {
8004     try {
8005       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8006     } catch (std::out_of_range& e) {
8007       {
8008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8009       };
8010     } catch (std::exception& e) {
8011       {
8012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8013       };
8014     } catch (Dali::DaliException e) {
8015       {
8016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8017       };
8018     } catch (...) {
8019       {
8020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8021       };
8022     }
8023   }
8024
8025   jresult = (void *)result;
8026   return jresult;
8027 }
8028
8029
8030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8031   void * jresult ;
8032   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8033   float arg2 ;
8034   Dali::Vector4 *result = 0 ;
8035
8036   arg1 = (Dali::Vector4 *)jarg1;
8037   arg2 = (float)jarg2;
8038   {
8039     try {
8040       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8041     } catch (std::out_of_range& e) {
8042       {
8043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8044       };
8045     } catch (std::exception& e) {
8046       {
8047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8048       };
8049     } catch (Dali::DaliException e) {
8050       {
8051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8052       };
8053     } catch (...) {
8054       {
8055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8056       };
8057     }
8058   }
8059
8060   jresult = (void *)result;
8061   return jresult;
8062 }
8063
8064
8065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8066   void * jresult ;
8067   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8068   Dali::Vector4 result;
8069
8070   arg1 = (Dali::Vector4 *)jarg1;
8071   {
8072     try {
8073       result = ((Dali::Vector4 const *)arg1)->operator -();
8074     } catch (std::out_of_range& e) {
8075       {
8076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8077       };
8078     } catch (std::exception& e) {
8079       {
8080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8081       };
8082     } catch (Dali::DaliException e) {
8083       {
8084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8085       };
8086     } catch (...) {
8087       {
8088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8089       };
8090     }
8091   }
8092
8093   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8094   return jresult;
8095 }
8096
8097
8098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8099   unsigned int jresult ;
8100   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8101   Dali::Vector4 *arg2 = 0 ;
8102   bool result;
8103
8104   arg1 = (Dali::Vector4 *)jarg1;
8105   arg2 = (Dali::Vector4 *)jarg2;
8106   if (!arg2) {
8107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8108     return 0;
8109   }
8110   {
8111     try {
8112       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8113     } catch (std::out_of_range& e) {
8114       {
8115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8116       };
8117     } catch (std::exception& e) {
8118       {
8119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8120       };
8121     } catch (Dali::DaliException e) {
8122       {
8123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8124       };
8125     } catch (...) {
8126       {
8127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8128       };
8129     }
8130   }
8131
8132   jresult = result;
8133   return jresult;
8134 }
8135
8136
8137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8138   unsigned int jresult ;
8139   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8140   Dali::Vector4 *arg2 = 0 ;
8141   bool result;
8142
8143   arg1 = (Dali::Vector4 *)jarg1;
8144   arg2 = (Dali::Vector4 *)jarg2;
8145   if (!arg2) {
8146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8147     return 0;
8148   }
8149   {
8150     try {
8151       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8152     } catch (std::out_of_range& e) {
8153       {
8154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8155       };
8156     } catch (std::exception& e) {
8157       {
8158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8159       };
8160     } catch (Dali::DaliException e) {
8161       {
8162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8163       };
8164     } catch (...) {
8165       {
8166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8167       };
8168     }
8169   }
8170
8171   jresult = result;
8172   return jresult;
8173 }
8174
8175
8176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8177   float jresult ;
8178   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8179   unsigned int arg2 ;
8180   float *result = 0 ;
8181
8182   arg1 = (Dali::Vector4 *)jarg1;
8183   arg2 = (unsigned int)jarg2;
8184   {
8185     try {
8186       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8187     } catch (std::out_of_range& e) {
8188       {
8189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8190       };
8191     } catch (std::exception& e) {
8192       {
8193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8194       };
8195     } catch (Dali::DaliException e) {
8196       {
8197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8198       };
8199     } catch (...) {
8200       {
8201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8202       };
8203     }
8204   }
8205
8206   jresult = *result;
8207   return jresult;
8208 }
8209
8210
8211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8212   float jresult ;
8213   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8214   Dali::Vector3 *arg2 = 0 ;
8215   float result;
8216
8217   arg1 = (Dali::Vector4 *)jarg1;
8218   arg2 = (Dali::Vector3 *)jarg2;
8219   if (!arg2) {
8220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8221     return 0;
8222   }
8223   {
8224     try {
8225       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8226     } catch (std::out_of_range& e) {
8227       {
8228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8229       };
8230     } catch (std::exception& e) {
8231       {
8232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8233       };
8234     } catch (Dali::DaliException e) {
8235       {
8236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8237       };
8238     } catch (...) {
8239       {
8240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8241       };
8242     }
8243   }
8244
8245   jresult = result;
8246   return jresult;
8247 }
8248
8249
8250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8251   float jresult ;
8252   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8253   Dali::Vector4 *arg2 = 0 ;
8254   float result;
8255
8256   arg1 = (Dali::Vector4 *)jarg1;
8257   arg2 = (Dali::Vector4 *)jarg2;
8258   if (!arg2) {
8259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8260     return 0;
8261   }
8262   {
8263     try {
8264       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8265     } catch (std::out_of_range& e) {
8266       {
8267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8268       };
8269     } catch (std::exception& e) {
8270       {
8271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8272       };
8273     } catch (Dali::DaliException e) {
8274       {
8275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8276       };
8277     } catch (...) {
8278       {
8279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8280       };
8281     }
8282   }
8283
8284   jresult = result;
8285   return jresult;
8286 }
8287
8288
8289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8290   float jresult ;
8291   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8292   Dali::Vector4 *arg2 = 0 ;
8293   float result;
8294
8295   arg1 = (Dali::Vector4 *)jarg1;
8296   arg2 = (Dali::Vector4 *)jarg2;
8297   if (!arg2) {
8298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8299     return 0;
8300   }
8301   {
8302     try {
8303       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8304     } catch (std::out_of_range& e) {
8305       {
8306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8307       };
8308     } catch (std::exception& e) {
8309       {
8310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8311       };
8312     } catch (Dali::DaliException e) {
8313       {
8314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8315       };
8316     } catch (...) {
8317       {
8318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8319       };
8320     }
8321   }
8322
8323   jresult = result;
8324   return jresult;
8325 }
8326
8327
8328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8329   void * jresult ;
8330   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8331   Dali::Vector4 *arg2 = 0 ;
8332   Dali::Vector4 result;
8333
8334   arg1 = (Dali::Vector4 *)jarg1;
8335   arg2 = (Dali::Vector4 *)jarg2;
8336   if (!arg2) {
8337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8338     return 0;
8339   }
8340   {
8341     try {
8342       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8343     } catch (std::out_of_range& e) {
8344       {
8345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8346       };
8347     } catch (std::exception& e) {
8348       {
8349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8350       };
8351     } catch (Dali::DaliException e) {
8352       {
8353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8354       };
8355     } catch (...) {
8356       {
8357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8358       };
8359     }
8360   }
8361
8362   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8363   return jresult;
8364 }
8365
8366
8367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8368   float jresult ;
8369   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8370   float result;
8371
8372   arg1 = (Dali::Vector4 *)jarg1;
8373   {
8374     try {
8375       result = (float)((Dali::Vector4 const *)arg1)->Length();
8376     } catch (std::out_of_range& e) {
8377       {
8378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8379       };
8380     } catch (std::exception& e) {
8381       {
8382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8383       };
8384     } catch (Dali::DaliException e) {
8385       {
8386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8387       };
8388     } catch (...) {
8389       {
8390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8391       };
8392     }
8393   }
8394
8395   jresult = result;
8396   return jresult;
8397 }
8398
8399
8400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8401   float jresult ;
8402   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8403   float result;
8404
8405   arg1 = (Dali::Vector4 *)jarg1;
8406   {
8407     try {
8408       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8409     } catch (std::out_of_range& e) {
8410       {
8411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8412       };
8413     } catch (std::exception& e) {
8414       {
8415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8416       };
8417     } catch (Dali::DaliException e) {
8418       {
8419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8420       };
8421     } catch (...) {
8422       {
8423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8424       };
8425     }
8426   }
8427
8428   jresult = result;
8429   return jresult;
8430 }
8431
8432
8433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8434   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8435
8436   arg1 = (Dali::Vector4 *)jarg1;
8437   {
8438     try {
8439       (arg1)->Normalize();
8440     } catch (std::out_of_range& e) {
8441       {
8442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8443       };
8444     } catch (std::exception& e) {
8445       {
8446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8447       };
8448     } catch (Dali::DaliException e) {
8449       {
8450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8451       };
8452     } catch (...) {
8453       {
8454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8455       };
8456     }
8457   }
8458
8459 }
8460
8461
8462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8463   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8464   Dali::Vector4 *arg2 = 0 ;
8465   Dali::Vector4 *arg3 = 0 ;
8466
8467   arg1 = (Dali::Vector4 *)jarg1;
8468   arg2 = (Dali::Vector4 *)jarg2;
8469   if (!arg2) {
8470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8471     return ;
8472   }
8473   arg3 = (Dali::Vector4 *)jarg3;
8474   if (!arg3) {
8475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8476     return ;
8477   }
8478   {
8479     try {
8480       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8481     } catch (std::out_of_range& e) {
8482       {
8483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8484       };
8485     } catch (std::exception& e) {
8486       {
8487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8488       };
8489     } catch (Dali::DaliException e) {
8490       {
8491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8492       };
8493     } catch (...) {
8494       {
8495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8496       };
8497     }
8498   }
8499
8500 }
8501
8502
8503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8504   void * jresult ;
8505   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8506   float *result = 0 ;
8507
8508   arg1 = (Dali::Vector4 *)jarg1;
8509   {
8510     try {
8511       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8512     } catch (std::out_of_range& e) {
8513       {
8514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8515       };
8516     } catch (std::exception& e) {
8517       {
8518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8519       };
8520     } catch (Dali::DaliException e) {
8521       {
8522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8523       };
8524     } catch (...) {
8525       {
8526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8527       };
8528     }
8529   }
8530
8531   jresult = (void *)result;
8532   return jresult;
8533 }
8534
8535
8536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8537   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8538   float arg2 ;
8539
8540   arg1 = (Dali::Vector4 *)jarg1;
8541   arg2 = (float)jarg2;
8542   if (arg1) (arg1)->x = arg2;
8543 }
8544
8545
8546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8547   float jresult ;
8548   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8549   float result;
8550
8551   arg1 = (Dali::Vector4 *)jarg1;
8552   result = (float) ((arg1)->x);
8553   jresult = result;
8554   return jresult;
8555 }
8556
8557
8558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8559   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8560   float arg2 ;
8561
8562   arg1 = (Dali::Vector4 *)jarg1;
8563   arg2 = (float)jarg2;
8564   if (arg1) (arg1)->r = arg2;
8565 }
8566
8567
8568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8569   float jresult ;
8570   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8571   float result;
8572
8573   arg1 = (Dali::Vector4 *)jarg1;
8574   result = (float) ((arg1)->r);
8575   jresult = result;
8576   return jresult;
8577 }
8578
8579
8580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8581   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8582   float arg2 ;
8583
8584   arg1 = (Dali::Vector4 *)jarg1;
8585   arg2 = (float)jarg2;
8586   if (arg1) (arg1)->s = arg2;
8587 }
8588
8589
8590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8591   float jresult ;
8592   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8593   float result;
8594
8595   arg1 = (Dali::Vector4 *)jarg1;
8596   result = (float) ((arg1)->s);
8597   jresult = result;
8598   return jresult;
8599 }
8600
8601
8602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8603   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8604   float arg2 ;
8605
8606   arg1 = (Dali::Vector4 *)jarg1;
8607   arg2 = (float)jarg2;
8608   if (arg1) (arg1)->y = arg2;
8609 }
8610
8611
8612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8613   float jresult ;
8614   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8615   float result;
8616
8617   arg1 = (Dali::Vector4 *)jarg1;
8618   result = (float) ((arg1)->y);
8619   jresult = result;
8620   return jresult;
8621 }
8622
8623
8624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8625   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8626   float arg2 ;
8627
8628   arg1 = (Dali::Vector4 *)jarg1;
8629   arg2 = (float)jarg2;
8630   if (arg1) (arg1)->g = arg2;
8631 }
8632
8633
8634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8635   float jresult ;
8636   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8637   float result;
8638
8639   arg1 = (Dali::Vector4 *)jarg1;
8640   result = (float) ((arg1)->g);
8641   jresult = result;
8642   return jresult;
8643 }
8644
8645
8646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8647   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8648   float arg2 ;
8649
8650   arg1 = (Dali::Vector4 *)jarg1;
8651   arg2 = (float)jarg2;
8652   if (arg1) (arg1)->t = arg2;
8653 }
8654
8655
8656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8657   float jresult ;
8658   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8659   float result;
8660
8661   arg1 = (Dali::Vector4 *)jarg1;
8662   result = (float) ((arg1)->t);
8663   jresult = result;
8664   return jresult;
8665 }
8666
8667
8668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8669   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8670   float arg2 ;
8671
8672   arg1 = (Dali::Vector4 *)jarg1;
8673   arg2 = (float)jarg2;
8674   if (arg1) (arg1)->z = arg2;
8675 }
8676
8677
8678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8679   float jresult ;
8680   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8681   float result;
8682
8683   arg1 = (Dali::Vector4 *)jarg1;
8684   result = (float) ((arg1)->z);
8685   jresult = result;
8686   return jresult;
8687 }
8688
8689
8690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8691   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8692   float arg2 ;
8693
8694   arg1 = (Dali::Vector4 *)jarg1;
8695   arg2 = (float)jarg2;
8696   if (arg1) (arg1)->b = arg2;
8697 }
8698
8699
8700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8701   float jresult ;
8702   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8703   float result;
8704
8705   arg1 = (Dali::Vector4 *)jarg1;
8706   result = (float) ((arg1)->b);
8707   jresult = result;
8708   return jresult;
8709 }
8710
8711
8712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8713   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8714   float arg2 ;
8715
8716   arg1 = (Dali::Vector4 *)jarg1;
8717   arg2 = (float)jarg2;
8718   if (arg1) (arg1)->p = arg2;
8719 }
8720
8721
8722 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8723   float jresult ;
8724   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8725   float result;
8726
8727   arg1 = (Dali::Vector4 *)jarg1;
8728   result = (float) ((arg1)->p);
8729   jresult = result;
8730   return jresult;
8731 }
8732
8733
8734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8735   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8736   float arg2 ;
8737
8738   arg1 = (Dali::Vector4 *)jarg1;
8739   arg2 = (float)jarg2;
8740   if (arg1) (arg1)->w = arg2;
8741 }
8742
8743
8744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8745   float jresult ;
8746   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8747   float result;
8748
8749   arg1 = (Dali::Vector4 *)jarg1;
8750   result = (float) ((arg1)->w);
8751   jresult = result;
8752   return jresult;
8753 }
8754
8755
8756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8757   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8758   float arg2 ;
8759
8760   arg1 = (Dali::Vector4 *)jarg1;
8761   arg2 = (float)jarg2;
8762   if (arg1) (arg1)->a = arg2;
8763 }
8764
8765
8766 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8767   float jresult ;
8768   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8769   float result;
8770
8771   arg1 = (Dali::Vector4 *)jarg1;
8772   result = (float) ((arg1)->a);
8773   jresult = result;
8774   return jresult;
8775 }
8776
8777
8778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8779   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8780   float arg2 ;
8781
8782   arg1 = (Dali::Vector4 *)jarg1;
8783   arg2 = (float)jarg2;
8784   if (arg1) (arg1)->q = arg2;
8785 }
8786
8787
8788 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8789   float jresult ;
8790   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8791   float result;
8792
8793   arg1 = (Dali::Vector4 *)jarg1;
8794   result = (float) ((arg1)->q);
8795   jresult = result;
8796   return jresult;
8797 }
8798
8799
8800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8801   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8802
8803   arg1 = (Dali::Vector4 *)jarg1;
8804   {
8805     try {
8806       delete arg1;
8807     } catch (std::out_of_range& e) {
8808       {
8809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8810       };
8811     } catch (std::exception& e) {
8812       {
8813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8814       };
8815     } catch (Dali::DaliException e) {
8816       {
8817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8818       };
8819     } catch (...) {
8820       {
8821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8822       };
8823     }
8824   }
8825
8826 }
8827
8828
8829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8830   void * jresult ;
8831   Dali::Vector4 *arg1 = 0 ;
8832   Dali::Vector4 *arg2 = 0 ;
8833   Dali::Vector4 result;
8834
8835   arg1 = (Dali::Vector4 *)jarg1;
8836   if (!arg1) {
8837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8838     return 0;
8839   }
8840   arg2 = (Dali::Vector4 *)jarg2;
8841   if (!arg2) {
8842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8843     return 0;
8844   }
8845   {
8846     try {
8847       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8848     } catch (std::out_of_range& e) {
8849       {
8850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8851       };
8852     } catch (std::exception& e) {
8853       {
8854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8855       };
8856     } catch (Dali::DaliException e) {
8857       {
8858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8859       };
8860     } catch (...) {
8861       {
8862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8863       };
8864     }
8865   }
8866
8867   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8868   return jresult;
8869 }
8870
8871
8872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8873   void * jresult ;
8874   Dali::Vector4 *arg1 = 0 ;
8875   Dali::Vector4 *arg2 = 0 ;
8876   Dali::Vector4 result;
8877
8878   arg1 = (Dali::Vector4 *)jarg1;
8879   if (!arg1) {
8880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8881     return 0;
8882   }
8883   arg2 = (Dali::Vector4 *)jarg2;
8884   if (!arg2) {
8885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8886     return 0;
8887   }
8888   {
8889     try {
8890       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8891     } catch (std::out_of_range& e) {
8892       {
8893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8894       };
8895     } catch (std::exception& e) {
8896       {
8897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8898       };
8899     } catch (Dali::DaliException e) {
8900       {
8901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8902       };
8903     } catch (...) {
8904       {
8905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8906       };
8907     }
8908   }
8909
8910   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8911   return jresult;
8912 }
8913
8914
8915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8916   void * jresult ;
8917   Dali::Vector4 *arg1 = 0 ;
8918   float *arg2 = 0 ;
8919   float *arg3 = 0 ;
8920   float temp2 ;
8921   float temp3 ;
8922   Dali::Vector4 result;
8923
8924   arg1 = (Dali::Vector4 *)jarg1;
8925   if (!arg1) {
8926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8927     return 0;
8928   }
8929   temp2 = (float)jarg2;
8930   arg2 = &temp2;
8931   temp3 = (float)jarg3;
8932   arg3 = &temp3;
8933   {
8934     try {
8935       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8936     } catch (std::out_of_range& e) {
8937       {
8938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8939       };
8940     } catch (std::exception& e) {
8941       {
8942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8943       };
8944     } catch (Dali::DaliException e) {
8945       {
8946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8947       };
8948     } catch (...) {
8949       {
8950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8951       };
8952     }
8953   }
8954
8955   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8956   return jresult;
8957 }
8958
8959
8960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8961   void * jresult ;
8962   Dali::Uint16Pair *result = 0 ;
8963
8964   {
8965     try {
8966       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8967     } catch (std::out_of_range& e) {
8968       {
8969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8970       };
8971     } catch (std::exception& e) {
8972       {
8973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8974       };
8975     } catch (Dali::DaliException e) {
8976       {
8977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8978       };
8979     } catch (...) {
8980       {
8981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8982       };
8983     }
8984   }
8985
8986   jresult = (void *)result;
8987   return jresult;
8988 }
8989
8990
8991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8992   void * jresult ;
8993   uint32_t arg1 ;
8994   uint32_t arg2 ;
8995   Dali::Uint16Pair *result = 0 ;
8996
8997   arg1 = (uint32_t)jarg1;
8998   arg2 = (uint32_t)jarg2;
8999   {
9000     try {
9001       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
9002     } catch (std::out_of_range& e) {
9003       {
9004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9005       };
9006     } catch (std::exception& e) {
9007       {
9008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9009       };
9010     } catch (Dali::DaliException e) {
9011       {
9012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9013       };
9014     } catch (...) {
9015       {
9016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9017       };
9018     }
9019   }
9020
9021   jresult = (void *)result;
9022   return jresult;
9023 }
9024
9025
9026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9027   void * jresult ;
9028   Dali::Uint16Pair *arg1 = 0 ;
9029   Dali::Uint16Pair *result = 0 ;
9030
9031   arg1 = (Dali::Uint16Pair *)jarg1;
9032   if (!arg1) {
9033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9034     return 0;
9035   }
9036   {
9037     try {
9038       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9039     } catch (std::out_of_range& e) {
9040       {
9041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9042       };
9043     } catch (std::exception& e) {
9044       {
9045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9046       };
9047     } catch (Dali::DaliException e) {
9048       {
9049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9050       };
9051     } catch (...) {
9052       {
9053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9054       };
9055     }
9056   }
9057
9058   jresult = (void *)result;
9059   return jresult;
9060 }
9061
9062
9063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9064   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9065   uint16_t arg2 ;
9066
9067   arg1 = (Dali::Uint16Pair *)jarg1;
9068   arg2 = (uint16_t)jarg2;
9069   {
9070     try {
9071       (arg1)->SetWidth(arg2);
9072     } catch (std::out_of_range& e) {
9073       {
9074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9075       };
9076     } catch (std::exception& e) {
9077       {
9078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9079       };
9080     } catch (Dali::DaliException e) {
9081       {
9082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9083       };
9084     } catch (...) {
9085       {
9086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9087       };
9088     }
9089   }
9090
9091 }
9092
9093
9094 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9095   unsigned short jresult ;
9096   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9097   uint16_t result;
9098
9099   arg1 = (Dali::Uint16Pair *)jarg1;
9100   {
9101     try {
9102       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9103     } catch (std::out_of_range& e) {
9104       {
9105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9106       };
9107     } catch (std::exception& e) {
9108       {
9109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9110       };
9111     } catch (Dali::DaliException e) {
9112       {
9113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9114       };
9115     } catch (...) {
9116       {
9117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9118       };
9119     }
9120   }
9121
9122   jresult = result;
9123   return jresult;
9124 }
9125
9126
9127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9128   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9129   uint16_t arg2 ;
9130
9131   arg1 = (Dali::Uint16Pair *)jarg1;
9132   arg2 = (uint16_t)jarg2;
9133   {
9134     try {
9135       (arg1)->SetHeight(arg2);
9136     } catch (std::out_of_range& e) {
9137       {
9138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9139       };
9140     } catch (std::exception& e) {
9141       {
9142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9143       };
9144     } catch (Dali::DaliException e) {
9145       {
9146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9147       };
9148     } catch (...) {
9149       {
9150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9151       };
9152     }
9153   }
9154
9155 }
9156
9157
9158 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9159   unsigned short jresult ;
9160   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9161   uint16_t result;
9162
9163   arg1 = (Dali::Uint16Pair *)jarg1;
9164   {
9165     try {
9166       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9167     } catch (std::out_of_range& e) {
9168       {
9169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9170       };
9171     } catch (std::exception& e) {
9172       {
9173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9174       };
9175     } catch (Dali::DaliException e) {
9176       {
9177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9178       };
9179     } catch (...) {
9180       {
9181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9182       };
9183     }
9184   }
9185
9186   jresult = result;
9187   return jresult;
9188 }
9189
9190
9191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9192   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9193   uint16_t arg2 ;
9194
9195   arg1 = (Dali::Uint16Pair *)jarg1;
9196   arg2 = (uint16_t)jarg2;
9197   {
9198     try {
9199       (arg1)->SetX(arg2);
9200     } catch (std::out_of_range& e) {
9201       {
9202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9203       };
9204     } catch (std::exception& e) {
9205       {
9206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9207       };
9208     } catch (Dali::DaliException e) {
9209       {
9210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9211       };
9212     } catch (...) {
9213       {
9214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9215       };
9216     }
9217   }
9218
9219 }
9220
9221
9222 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9223   unsigned short jresult ;
9224   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9225   uint16_t result;
9226
9227   arg1 = (Dali::Uint16Pair *)jarg1;
9228   {
9229     try {
9230       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9231     } catch (std::out_of_range& e) {
9232       {
9233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9234       };
9235     } catch (std::exception& e) {
9236       {
9237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9238       };
9239     } catch (Dali::DaliException e) {
9240       {
9241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9242       };
9243     } catch (...) {
9244       {
9245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9246       };
9247     }
9248   }
9249
9250   jresult = result;
9251   return jresult;
9252 }
9253
9254
9255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9256   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9257   uint16_t arg2 ;
9258
9259   arg1 = (Dali::Uint16Pair *)jarg1;
9260   arg2 = (uint16_t)jarg2;
9261   {
9262     try {
9263       (arg1)->SetY(arg2);
9264     } catch (std::out_of_range& e) {
9265       {
9266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9267       };
9268     } catch (std::exception& e) {
9269       {
9270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9271       };
9272     } catch (Dali::DaliException e) {
9273       {
9274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9275       };
9276     } catch (...) {
9277       {
9278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9279       };
9280     }
9281   }
9282
9283 }
9284
9285
9286 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9287   unsigned short jresult ;
9288   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9289   uint16_t result;
9290
9291   arg1 = (Dali::Uint16Pair *)jarg1;
9292   {
9293     try {
9294       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9295     } catch (std::out_of_range& e) {
9296       {
9297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9298       };
9299     } catch (std::exception& e) {
9300       {
9301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9302       };
9303     } catch (Dali::DaliException e) {
9304       {
9305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9306       };
9307     } catch (...) {
9308       {
9309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9310       };
9311     }
9312   }
9313
9314   jresult = result;
9315   return jresult;
9316 }
9317
9318
9319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9320   void * jresult ;
9321   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9322   Dali::Uint16Pair *arg2 = 0 ;
9323   Dali::Uint16Pair *result = 0 ;
9324
9325   arg1 = (Dali::Uint16Pair *)jarg1;
9326   arg2 = (Dali::Uint16Pair *)jarg2;
9327   if (!arg2) {
9328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9329     return 0;
9330   }
9331   {
9332     try {
9333       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9334     } catch (std::out_of_range& e) {
9335       {
9336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9337       };
9338     } catch (std::exception& e) {
9339       {
9340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9341       };
9342     } catch (Dali::DaliException e) {
9343       {
9344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9345       };
9346     } catch (...) {
9347       {
9348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9349       };
9350     }
9351   }
9352
9353   jresult = (void *)result;
9354   return jresult;
9355 }
9356
9357
9358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9359   unsigned int jresult ;
9360   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9361   Dali::Uint16Pair *arg2 = 0 ;
9362   bool result;
9363
9364   arg1 = (Dali::Uint16Pair *)jarg1;
9365   arg2 = (Dali::Uint16Pair *)jarg2;
9366   if (!arg2) {
9367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9368     return 0;
9369   }
9370   {
9371     try {
9372       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9373     } catch (std::out_of_range& e) {
9374       {
9375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9376       };
9377     } catch (std::exception& e) {
9378       {
9379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9380       };
9381     } catch (Dali::DaliException e) {
9382       {
9383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9384       };
9385     } catch (...) {
9386       {
9387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9388       };
9389     }
9390   }
9391
9392   jresult = result;
9393   return jresult;
9394 }
9395
9396
9397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9398   unsigned int jresult ;
9399   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9400   Dali::Uint16Pair *arg2 = 0 ;
9401   bool result;
9402
9403   arg1 = (Dali::Uint16Pair *)jarg1;
9404   arg2 = (Dali::Uint16Pair *)jarg2;
9405   if (!arg2) {
9406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9407     return 0;
9408   }
9409   {
9410     try {
9411       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9412     } catch (std::out_of_range& e) {
9413       {
9414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9415       };
9416     } catch (std::exception& e) {
9417       {
9418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9419       };
9420     } catch (Dali::DaliException e) {
9421       {
9422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9423       };
9424     } catch (...) {
9425       {
9426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9427       };
9428     }
9429   }
9430
9431   jresult = result;
9432   return jresult;
9433 }
9434
9435
9436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9437   unsigned int jresult ;
9438   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9439   Dali::Uint16Pair *arg2 = 0 ;
9440   bool result;
9441
9442   arg1 = (Dali::Uint16Pair *)jarg1;
9443   arg2 = (Dali::Uint16Pair *)jarg2;
9444   if (!arg2) {
9445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9446     return 0;
9447   }
9448   {
9449     try {
9450       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9451     } catch (std::out_of_range& e) {
9452       {
9453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9454       };
9455     } catch (std::exception& e) {
9456       {
9457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9458       };
9459     } catch (Dali::DaliException e) {
9460       {
9461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9462       };
9463     } catch (...) {
9464       {
9465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9466       };
9467     }
9468   }
9469
9470   jresult = result;
9471   return jresult;
9472 }
9473
9474
9475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9476   unsigned int jresult ;
9477   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9478   Dali::Uint16Pair *arg2 = 0 ;
9479   bool result;
9480
9481   arg1 = (Dali::Uint16Pair *)jarg1;
9482   arg2 = (Dali::Uint16Pair *)jarg2;
9483   if (!arg2) {
9484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9485     return 0;
9486   }
9487   {
9488     try {
9489       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9490     } catch (std::out_of_range& e) {
9491       {
9492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9493       };
9494     } catch (std::exception& e) {
9495       {
9496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9497       };
9498     } catch (Dali::DaliException e) {
9499       {
9500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9501       };
9502     } catch (...) {
9503       {
9504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9505       };
9506     }
9507   }
9508
9509   jresult = result;
9510   return jresult;
9511 }
9512
9513
9514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9515   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9516
9517   arg1 = (Dali::Uint16Pair *)jarg1;
9518   {
9519     try {
9520       delete arg1;
9521     } catch (std::out_of_range& e) {
9522       {
9523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9524       };
9525     } catch (std::exception& e) {
9526       {
9527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9528       };
9529     } catch (Dali::DaliException e) {
9530       {
9531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9532       };
9533     } catch (...) {
9534       {
9535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9536       };
9537     }
9538   }
9539
9540 }
9541
9542
9543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9544   void * jresult ;
9545   Dali::Degree *result = 0 ;
9546
9547   {
9548     try {
9549       result = (Dali::Degree *)new Dali::Degree();
9550     } catch (std::out_of_range& e) {
9551       {
9552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9553       };
9554     } catch (std::exception& e) {
9555       {
9556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9557       };
9558     } catch (Dali::DaliException e) {
9559       {
9560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9561       };
9562     } catch (...) {
9563       {
9564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9565       };
9566     }
9567   }
9568
9569   jresult = (void *)result;
9570   return jresult;
9571 }
9572
9573
9574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9575   void * jresult ;
9576   float arg1 ;
9577   Dali::Degree *result = 0 ;
9578
9579   arg1 = (float)jarg1;
9580   {
9581     try {
9582       result = (Dali::Degree *)new Dali::Degree(arg1);
9583     } catch (std::out_of_range& e) {
9584       {
9585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9586       };
9587     } catch (std::exception& e) {
9588       {
9589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9590       };
9591     } catch (Dali::DaliException e) {
9592       {
9593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9594       };
9595     } catch (...) {
9596       {
9597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9598       };
9599     }
9600   }
9601
9602   jresult = (void *)result;
9603   return jresult;
9604 }
9605
9606
9607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9608   void * jresult ;
9609   Dali::Radian arg1 ;
9610   Dali::Radian *argp1 ;
9611   Dali::Degree *result = 0 ;
9612
9613   argp1 = (Dali::Radian *)jarg1;
9614   if (!argp1) {
9615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9616     return 0;
9617   }
9618   arg1 = *argp1;
9619   {
9620     try {
9621       result = (Dali::Degree *)new Dali::Degree(arg1);
9622     } catch (std::out_of_range& e) {
9623       {
9624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9625       };
9626     } catch (std::exception& e) {
9627       {
9628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9629       };
9630     } catch (Dali::DaliException e) {
9631       {
9632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9633       };
9634     } catch (...) {
9635       {
9636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9637       };
9638     }
9639   }
9640
9641   jresult = (void *)result;
9642   return jresult;
9643 }
9644
9645
9646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9647   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9648   float arg2 ;
9649
9650   arg1 = (Dali::Degree *)jarg1;
9651   arg2 = (float)jarg2;
9652   if (arg1) (arg1)->degree = arg2;
9653 }
9654
9655
9656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9657   float jresult ;
9658   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9659   float result;
9660
9661   arg1 = (Dali::Degree *)jarg1;
9662   result = (float) ((arg1)->degree);
9663   jresult = result;
9664   return jresult;
9665 }
9666
9667
9668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9669   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9670
9671   arg1 = (Dali::Degree *)jarg1;
9672   {
9673     try {
9674       delete arg1;
9675     } catch (std::out_of_range& e) {
9676       {
9677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9678       };
9679     } catch (std::exception& e) {
9680       {
9681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9682       };
9683     } catch (Dali::DaliException e) {
9684       {
9685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9686       };
9687     } catch (...) {
9688       {
9689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9690       };
9691     }
9692   }
9693
9694 }
9695
9696
9697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9698   void * jresult ;
9699   Dali::Radian *result = 0 ;
9700
9701   result = (Dali::Radian *)&Dali::ANGLE_360;
9702   jresult = (void *)result;
9703   return jresult;
9704 }
9705
9706
9707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9708   void * jresult ;
9709   Dali::Radian *result = 0 ;
9710
9711   result = (Dali::Radian *)&Dali::ANGLE_315;
9712   jresult = (void *)result;
9713   return jresult;
9714 }
9715
9716
9717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9718   void * jresult ;
9719   Dali::Radian *result = 0 ;
9720
9721   result = (Dali::Radian *)&Dali::ANGLE_270;
9722   jresult = (void *)result;
9723   return jresult;
9724 }
9725
9726
9727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9728   void * jresult ;
9729   Dali::Radian *result = 0 ;
9730
9731   result = (Dali::Radian *)&Dali::ANGLE_225;
9732   jresult = (void *)result;
9733   return jresult;
9734 }
9735
9736
9737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9738   void * jresult ;
9739   Dali::Radian *result = 0 ;
9740
9741   result = (Dali::Radian *)&Dali::ANGLE_180;
9742   jresult = (void *)result;
9743   return jresult;
9744 }
9745
9746
9747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9748   void * jresult ;
9749   Dali::Radian *result = 0 ;
9750
9751   result = (Dali::Radian *)&Dali::ANGLE_135;
9752   jresult = (void *)result;
9753   return jresult;
9754 }
9755
9756
9757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9758   void * jresult ;
9759   Dali::Radian *result = 0 ;
9760
9761   result = (Dali::Radian *)&Dali::ANGLE_120;
9762   jresult = (void *)result;
9763   return jresult;
9764 }
9765
9766
9767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9768   void * jresult ;
9769   Dali::Radian *result = 0 ;
9770
9771   result = (Dali::Radian *)&Dali::ANGLE_90;
9772   jresult = (void *)result;
9773   return jresult;
9774 }
9775
9776
9777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9778   void * jresult ;
9779   Dali::Radian *result = 0 ;
9780
9781   result = (Dali::Radian *)&Dali::ANGLE_60;
9782   jresult = (void *)result;
9783   return jresult;
9784 }
9785
9786
9787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9788   void * jresult ;
9789   Dali::Radian *result = 0 ;
9790
9791   result = (Dali::Radian *)&Dali::ANGLE_45;
9792   jresult = (void *)result;
9793   return jresult;
9794 }
9795
9796
9797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9798   void * jresult ;
9799   Dali::Radian *result = 0 ;
9800
9801   result = (Dali::Radian *)&Dali::ANGLE_30;
9802   jresult = (void *)result;
9803   return jresult;
9804 }
9805
9806
9807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9808   void * jresult ;
9809   Dali::Radian *result = 0 ;
9810
9811   result = (Dali::Radian *)&Dali::ANGLE_0;
9812   jresult = (void *)result;
9813   return jresult;
9814 }
9815
9816
9817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9818   unsigned int jresult ;
9819   Dali::Degree *arg1 = 0 ;
9820   Dali::Degree *arg2 = 0 ;
9821   bool result;
9822
9823   arg1 = (Dali::Degree *)jarg1;
9824   if (!arg1) {
9825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9826     return 0;
9827   }
9828   arg2 = (Dali::Degree *)jarg2;
9829   if (!arg2) {
9830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9831     return 0;
9832   }
9833   {
9834     try {
9835       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9836     } catch (std::out_of_range& e) {
9837       {
9838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9839       };
9840     } catch (std::exception& e) {
9841       {
9842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9843       };
9844     } catch (Dali::DaliException e) {
9845       {
9846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9847       };
9848     } catch (...) {
9849       {
9850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9851       };
9852     }
9853   }
9854
9855   jresult = result;
9856   return jresult;
9857 }
9858
9859
9860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9861   unsigned int jresult ;
9862   Dali::Degree *arg1 = 0 ;
9863   Dali::Degree *arg2 = 0 ;
9864   bool result;
9865
9866   arg1 = (Dali::Degree *)jarg1;
9867   if (!arg1) {
9868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9869     return 0;
9870   }
9871   arg2 = (Dali::Degree *)jarg2;
9872   if (!arg2) {
9873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9874     return 0;
9875   }
9876   {
9877     try {
9878       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9879     } catch (std::out_of_range& e) {
9880       {
9881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9882       };
9883     } catch (std::exception& e) {
9884       {
9885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9886       };
9887     } catch (Dali::DaliException e) {
9888       {
9889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9890       };
9891     } catch (...) {
9892       {
9893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9894       };
9895     }
9896   }
9897
9898   jresult = result;
9899   return jresult;
9900 }
9901
9902
9903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9904   void * jresult ;
9905   Dali::Degree arg1 ;
9906   float arg2 ;
9907   float arg3 ;
9908   Dali::Degree *argp1 ;
9909   Dali::Degree result;
9910
9911   argp1 = (Dali::Degree *)jarg1;
9912   if (!argp1) {
9913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9914     return 0;
9915   }
9916   arg1 = *argp1;
9917   arg2 = (float)jarg2;
9918   arg3 = (float)jarg3;
9919   {
9920     try {
9921       result = Dali::Clamp(arg1,arg2,arg3);
9922     } catch (std::out_of_range& e) {
9923       {
9924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9925       };
9926     } catch (std::exception& e) {
9927       {
9928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9929       };
9930     } catch (Dali::DaliException e) {
9931       {
9932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9933       };
9934     } catch (...) {
9935       {
9936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9937       };
9938     }
9939   }
9940
9941   jresult = new Dali::Degree((const Dali::Degree &)result);
9942   return jresult;
9943 }
9944
9945
9946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9947   void * jresult ;
9948   Dali::Radian *result = 0 ;
9949
9950   {
9951     try {
9952       result = (Dali::Radian *)new Dali::Radian();
9953     } catch (std::out_of_range& e) {
9954       {
9955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9956       };
9957     } catch (std::exception& e) {
9958       {
9959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9960       };
9961     } catch (Dali::DaliException e) {
9962       {
9963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9964       };
9965     } catch (...) {
9966       {
9967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9968       };
9969     }
9970   }
9971
9972   jresult = (void *)result;
9973   return jresult;
9974 }
9975
9976
9977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9978   void * jresult ;
9979   float arg1 ;
9980   Dali::Radian *result = 0 ;
9981
9982   arg1 = (float)jarg1;
9983   {
9984     try {
9985       result = (Dali::Radian *)new Dali::Radian(arg1);
9986     } catch (std::out_of_range& e) {
9987       {
9988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9989       };
9990     } catch (std::exception& e) {
9991       {
9992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9993       };
9994     } catch (Dali::DaliException e) {
9995       {
9996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9997       };
9998     } catch (...) {
9999       {
10000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10001       };
10002     }
10003   }
10004
10005   jresult = (void *)result;
10006   return jresult;
10007 }
10008
10009
10010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10011   void * jresult ;
10012   Dali::Degree arg1 ;
10013   Dali::Degree *argp1 ;
10014   Dali::Radian *result = 0 ;
10015
10016   argp1 = (Dali::Degree *)jarg1;
10017   if (!argp1) {
10018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10019     return 0;
10020   }
10021   arg1 = *argp1;
10022   {
10023     try {
10024       result = (Dali::Radian *)new Dali::Radian(arg1);
10025     } catch (std::out_of_range& e) {
10026       {
10027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10028       };
10029     } catch (std::exception& e) {
10030       {
10031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10032       };
10033     } catch (Dali::DaliException e) {
10034       {
10035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10036       };
10037     } catch (...) {
10038       {
10039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10040       };
10041     }
10042   }
10043
10044   jresult = (void *)result;
10045   return jresult;
10046 }
10047
10048
10049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10050   void * jresult ;
10051   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10052   float arg2 ;
10053   Dali::Radian *result = 0 ;
10054
10055   arg1 = (Dali::Radian *)jarg1;
10056   arg2 = (float)jarg2;
10057   {
10058     try {
10059       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10060     } catch (std::out_of_range& e) {
10061       {
10062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10063       };
10064     } catch (std::exception& e) {
10065       {
10066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10067       };
10068     } catch (Dali::DaliException e) {
10069       {
10070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10071       };
10072     } catch (...) {
10073       {
10074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10075       };
10076     }
10077   }
10078
10079   jresult = (void *)result;
10080   return jresult;
10081 }
10082
10083
10084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10085   void * jresult ;
10086   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10087   Dali::Degree arg2 ;
10088   Dali::Degree *argp2 ;
10089   Dali::Radian *result = 0 ;
10090
10091   arg1 = (Dali::Radian *)jarg1;
10092   argp2 = (Dali::Degree *)jarg2;
10093   if (!argp2) {
10094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10095     return 0;
10096   }
10097   arg2 = *argp2;
10098   {
10099     try {
10100       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10101     } catch (std::out_of_range& e) {
10102       {
10103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10104       };
10105     } catch (std::exception& e) {
10106       {
10107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10108       };
10109     } catch (Dali::DaliException e) {
10110       {
10111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10112       };
10113     } catch (...) {
10114       {
10115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10116       };
10117     }
10118   }
10119
10120   jresult = (void *)result;
10121   return jresult;
10122 }
10123
10124
10125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10126   float jresult ;
10127   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10128   float result;
10129
10130   arg1 = (Dali::Radian *)jarg1;
10131   {
10132     try {
10133       result = (float)((Dali::Radian const *)arg1)->operator float();
10134     } catch (std::out_of_range& e) {
10135       {
10136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10137       };
10138     } catch (std::exception& e) {
10139       {
10140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10141       };
10142     } catch (Dali::DaliException e) {
10143       {
10144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10145       };
10146     } catch (...) {
10147       {
10148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10149       };
10150     }
10151   }
10152
10153   jresult = result;
10154   return jresult;
10155 }
10156
10157
10158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10159   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10160   float arg2 ;
10161
10162   arg1 = (Dali::Radian *)jarg1;
10163   arg2 = (float)jarg2;
10164   if (arg1) (arg1)->radian = arg2;
10165 }
10166
10167
10168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10169   float jresult ;
10170   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10171   float result;
10172
10173   arg1 = (Dali::Radian *)jarg1;
10174   result = (float) ((arg1)->radian);
10175   jresult = result;
10176   return jresult;
10177 }
10178
10179
10180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10181   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10182
10183   arg1 = (Dali::Radian *)jarg1;
10184   {
10185     try {
10186       delete arg1;
10187     } catch (std::out_of_range& e) {
10188       {
10189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10190       };
10191     } catch (std::exception& e) {
10192       {
10193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10194       };
10195     } catch (Dali::DaliException e) {
10196       {
10197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10198       };
10199     } catch (...) {
10200       {
10201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10202       };
10203     }
10204   }
10205
10206 }
10207
10208
10209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10210   unsigned int jresult ;
10211   Dali::Radian arg1 ;
10212   Dali::Radian arg2 ;
10213   Dali::Radian *argp1 ;
10214   Dali::Radian *argp2 ;
10215   bool result;
10216
10217   argp1 = (Dali::Radian *)jarg1;
10218   if (!argp1) {
10219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10220     return 0;
10221   }
10222   arg1 = *argp1;
10223   argp2 = (Dali::Radian *)jarg2;
10224   if (!argp2) {
10225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10226     return 0;
10227   }
10228   arg2 = *argp2;
10229   {
10230     try {
10231       result = (bool)Dali::operator ==(arg1,arg2);
10232     } catch (std::out_of_range& e) {
10233       {
10234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10235       };
10236     } catch (std::exception& e) {
10237       {
10238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10239       };
10240     } catch (Dali::DaliException e) {
10241       {
10242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10243       };
10244     } catch (...) {
10245       {
10246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10247       };
10248     }
10249   }
10250
10251   jresult = result;
10252   return jresult;
10253 }
10254
10255
10256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10257   unsigned int jresult ;
10258   Dali::Radian arg1 ;
10259   Dali::Radian arg2 ;
10260   Dali::Radian *argp1 ;
10261   Dali::Radian *argp2 ;
10262   bool result;
10263
10264   argp1 = (Dali::Radian *)jarg1;
10265   if (!argp1) {
10266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10267     return 0;
10268   }
10269   arg1 = *argp1;
10270   argp2 = (Dali::Radian *)jarg2;
10271   if (!argp2) {
10272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10273     return 0;
10274   }
10275   arg2 = *argp2;
10276   {
10277     try {
10278       result = (bool)Dali::operator !=(arg1,arg2);
10279     } catch (std::out_of_range& e) {
10280       {
10281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10282       };
10283     } catch (std::exception& e) {
10284       {
10285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10286       };
10287     } catch (Dali::DaliException e) {
10288       {
10289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10290       };
10291     } catch (...) {
10292       {
10293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10294       };
10295     }
10296   }
10297
10298   jresult = result;
10299   return jresult;
10300 }
10301
10302
10303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10304   unsigned int jresult ;
10305   Dali::Radian arg1 ;
10306   Dali::Degree arg2 ;
10307   Dali::Radian *argp1 ;
10308   Dali::Degree *argp2 ;
10309   bool result;
10310
10311   argp1 = (Dali::Radian *)jarg1;
10312   if (!argp1) {
10313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10314     return 0;
10315   }
10316   arg1 = *argp1;
10317   argp2 = (Dali::Degree *)jarg2;
10318   if (!argp2) {
10319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10320     return 0;
10321   }
10322   arg2 = *argp2;
10323   {
10324     try {
10325       result = (bool)Dali::operator ==(arg1,arg2);
10326     } catch (std::out_of_range& e) {
10327       {
10328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10329       };
10330     } catch (std::exception& e) {
10331       {
10332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10333       };
10334     } catch (Dali::DaliException e) {
10335       {
10336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10337       };
10338     } catch (...) {
10339       {
10340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10341       };
10342     }
10343   }
10344
10345   jresult = result;
10346   return jresult;
10347 }
10348
10349
10350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10351   unsigned int jresult ;
10352   Dali::Radian arg1 ;
10353   Dali::Degree arg2 ;
10354   Dali::Radian *argp1 ;
10355   Dali::Degree *argp2 ;
10356   bool result;
10357
10358   argp1 = (Dali::Radian *)jarg1;
10359   if (!argp1) {
10360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10361     return 0;
10362   }
10363   arg1 = *argp1;
10364   argp2 = (Dali::Degree *)jarg2;
10365   if (!argp2) {
10366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10367     return 0;
10368   }
10369   arg2 = *argp2;
10370   {
10371     try {
10372       result = (bool)Dali::operator !=(arg1,arg2);
10373     } catch (std::out_of_range& e) {
10374       {
10375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10376       };
10377     } catch (std::exception& e) {
10378       {
10379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10380       };
10381     } catch (Dali::DaliException e) {
10382       {
10383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10384       };
10385     } catch (...) {
10386       {
10387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10388       };
10389     }
10390   }
10391
10392   jresult = result;
10393   return jresult;
10394 }
10395
10396
10397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10398   unsigned int jresult ;
10399   Dali::Degree arg1 ;
10400   Dali::Radian arg2 ;
10401   Dali::Degree *argp1 ;
10402   Dali::Radian *argp2 ;
10403   bool result;
10404
10405   argp1 = (Dali::Degree *)jarg1;
10406   if (!argp1) {
10407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10408     return 0;
10409   }
10410   arg1 = *argp1;
10411   argp2 = (Dali::Radian *)jarg2;
10412   if (!argp2) {
10413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10414     return 0;
10415   }
10416   arg2 = *argp2;
10417   {
10418     try {
10419       result = (bool)Dali::operator ==(arg1,arg2);
10420     } catch (std::out_of_range& e) {
10421       {
10422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10423       };
10424     } catch (std::exception& e) {
10425       {
10426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10427       };
10428     } catch (Dali::DaliException e) {
10429       {
10430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10431       };
10432     } catch (...) {
10433       {
10434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10435       };
10436     }
10437   }
10438
10439   jresult = result;
10440   return jresult;
10441 }
10442
10443
10444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10445   unsigned int jresult ;
10446   Dali::Degree arg1 ;
10447   Dali::Radian arg2 ;
10448   Dali::Degree *argp1 ;
10449   Dali::Radian *argp2 ;
10450   bool result;
10451
10452   argp1 = (Dali::Degree *)jarg1;
10453   if (!argp1) {
10454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10455     return 0;
10456   }
10457   arg1 = *argp1;
10458   argp2 = (Dali::Radian *)jarg2;
10459   if (!argp2) {
10460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10461     return 0;
10462   }
10463   arg2 = *argp2;
10464   {
10465     try {
10466       result = (bool)Dali::operator !=(arg1,arg2);
10467     } catch (std::out_of_range& e) {
10468       {
10469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10470       };
10471     } catch (std::exception& e) {
10472       {
10473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10474       };
10475     } catch (Dali::DaliException e) {
10476       {
10477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10478       };
10479     } catch (...) {
10480       {
10481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10482       };
10483     }
10484   }
10485
10486   jresult = result;
10487   return jresult;
10488 }
10489
10490
10491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10492   unsigned int jresult ;
10493   Dali::Radian arg1 ;
10494   Dali::Radian arg2 ;
10495   Dali::Radian *argp1 ;
10496   Dali::Radian *argp2 ;
10497   bool result;
10498
10499   argp1 = (Dali::Radian *)jarg1;
10500   if (!argp1) {
10501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10502     return 0;
10503   }
10504   arg1 = *argp1;
10505   argp2 = (Dali::Radian *)jarg2;
10506   if (!argp2) {
10507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10508     return 0;
10509   }
10510   arg2 = *argp2;
10511   {
10512     try {
10513       result = (bool)Dali::operator >(arg1,arg2);
10514     } catch (std::out_of_range& e) {
10515       {
10516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10517       };
10518     } catch (std::exception& e) {
10519       {
10520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10521       };
10522     } catch (Dali::DaliException e) {
10523       {
10524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10525       };
10526     } catch (...) {
10527       {
10528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10529       };
10530     }
10531   }
10532
10533   jresult = result;
10534   return jresult;
10535 }
10536
10537
10538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10539   unsigned int jresult ;
10540   Dali::Radian arg1 ;
10541   Dali::Degree arg2 ;
10542   Dali::Radian *argp1 ;
10543   Dali::Degree *argp2 ;
10544   bool result;
10545
10546   argp1 = (Dali::Radian *)jarg1;
10547   if (!argp1) {
10548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10549     return 0;
10550   }
10551   arg1 = *argp1;
10552   argp2 = (Dali::Degree *)jarg2;
10553   if (!argp2) {
10554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10555     return 0;
10556   }
10557   arg2 = *argp2;
10558   {
10559     try {
10560       result = (bool)Dali::operator >(arg1,arg2);
10561     } catch (std::out_of_range& e) {
10562       {
10563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10564       };
10565     } catch (std::exception& e) {
10566       {
10567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10568       };
10569     } catch (Dali::DaliException e) {
10570       {
10571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10572       };
10573     } catch (...) {
10574       {
10575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10576       };
10577     }
10578   }
10579
10580   jresult = result;
10581   return jresult;
10582 }
10583
10584
10585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10586   unsigned int jresult ;
10587   Dali::Degree arg1 ;
10588   Dali::Radian arg2 ;
10589   Dali::Degree *argp1 ;
10590   Dali::Radian *argp2 ;
10591   bool result;
10592
10593   argp1 = (Dali::Degree *)jarg1;
10594   if (!argp1) {
10595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10596     return 0;
10597   }
10598   arg1 = *argp1;
10599   argp2 = (Dali::Radian *)jarg2;
10600   if (!argp2) {
10601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10602     return 0;
10603   }
10604   arg2 = *argp2;
10605   {
10606     try {
10607       result = (bool)Dali::operator >(arg1,arg2);
10608     } catch (std::out_of_range& e) {
10609       {
10610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10611       };
10612     } catch (std::exception& e) {
10613       {
10614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10615       };
10616     } catch (Dali::DaliException e) {
10617       {
10618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10619       };
10620     } catch (...) {
10621       {
10622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10623       };
10624     }
10625   }
10626
10627   jresult = result;
10628   return jresult;
10629 }
10630
10631
10632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10633   unsigned int jresult ;
10634   Dali::Radian arg1 ;
10635   Dali::Radian arg2 ;
10636   Dali::Radian *argp1 ;
10637   Dali::Radian *argp2 ;
10638   bool result;
10639
10640   argp1 = (Dali::Radian *)jarg1;
10641   if (!argp1) {
10642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10643     return 0;
10644   }
10645   arg1 = *argp1;
10646   argp2 = (Dali::Radian *)jarg2;
10647   if (!argp2) {
10648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10649     return 0;
10650   }
10651   arg2 = *argp2;
10652   {
10653     try {
10654       result = (bool)Dali::operator <(arg1,arg2);
10655     } catch (std::out_of_range& e) {
10656       {
10657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10658       };
10659     } catch (std::exception& e) {
10660       {
10661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10662       };
10663     } catch (Dali::DaliException e) {
10664       {
10665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10666       };
10667     } catch (...) {
10668       {
10669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10670       };
10671     }
10672   }
10673
10674   jresult = result;
10675   return jresult;
10676 }
10677
10678
10679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10680   unsigned int jresult ;
10681   Dali::Radian arg1 ;
10682   Dali::Degree arg2 ;
10683   Dali::Radian *argp1 ;
10684   Dali::Degree *argp2 ;
10685   bool result;
10686
10687   argp1 = (Dali::Radian *)jarg1;
10688   if (!argp1) {
10689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10690     return 0;
10691   }
10692   arg1 = *argp1;
10693   argp2 = (Dali::Degree *)jarg2;
10694   if (!argp2) {
10695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10696     return 0;
10697   }
10698   arg2 = *argp2;
10699   {
10700     try {
10701       result = (bool)Dali::operator <(arg1,arg2);
10702     } catch (std::out_of_range& e) {
10703       {
10704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10705       };
10706     } catch (std::exception& e) {
10707       {
10708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10709       };
10710     } catch (Dali::DaliException e) {
10711       {
10712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10713       };
10714     } catch (...) {
10715       {
10716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10717       };
10718     }
10719   }
10720
10721   jresult = result;
10722   return jresult;
10723 }
10724
10725
10726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10727   unsigned int jresult ;
10728   Dali::Degree arg1 ;
10729   Dali::Radian arg2 ;
10730   Dali::Degree *argp1 ;
10731   Dali::Radian *argp2 ;
10732   bool result;
10733
10734   argp1 = (Dali::Degree *)jarg1;
10735   if (!argp1) {
10736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10737     return 0;
10738   }
10739   arg1 = *argp1;
10740   argp2 = (Dali::Radian *)jarg2;
10741   if (!argp2) {
10742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10743     return 0;
10744   }
10745   arg2 = *argp2;
10746   {
10747     try {
10748       result = (bool)Dali::operator <(arg1,arg2);
10749     } catch (std::out_of_range& e) {
10750       {
10751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10752       };
10753     } catch (std::exception& e) {
10754       {
10755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10756       };
10757     } catch (Dali::DaliException e) {
10758       {
10759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10760       };
10761     } catch (...) {
10762       {
10763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10764       };
10765     }
10766   }
10767
10768   jresult = result;
10769   return jresult;
10770 }
10771
10772
10773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10774   void * jresult ;
10775   Dali::Radian arg1 ;
10776   float arg2 ;
10777   Dali::Radian *argp1 ;
10778   Dali::Radian result;
10779
10780   argp1 = (Dali::Radian *)jarg1;
10781   if (!argp1) {
10782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10783     return 0;
10784   }
10785   arg1 = *argp1;
10786   arg2 = (float)jarg2;
10787   {
10788     try {
10789       result = Dali::operator *(arg1,arg2);
10790     } catch (std::out_of_range& e) {
10791       {
10792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10793       };
10794     } catch (std::exception& e) {
10795       {
10796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10797       };
10798     } catch (Dali::DaliException e) {
10799       {
10800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10801       };
10802     } catch (...) {
10803       {
10804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10805       };
10806     }
10807   }
10808
10809   jresult = new Dali::Radian((const Dali::Radian &)result);
10810   return jresult;
10811 }
10812
10813
10814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10815   void * jresult ;
10816   Dali::Radian arg1 ;
10817   Dali::Radian *argp1 ;
10818   Dali::Radian result;
10819
10820   argp1 = (Dali::Radian *)jarg1;
10821   if (!argp1) {
10822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10823     return 0;
10824   }
10825   arg1 = *argp1;
10826   {
10827     try {
10828       result = Dali::operator -(arg1);
10829     } catch (std::out_of_range& e) {
10830       {
10831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10832       };
10833     } catch (std::exception& e) {
10834       {
10835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10836       };
10837     } catch (Dali::DaliException e) {
10838       {
10839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10840       };
10841     } catch (...) {
10842       {
10843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10844       };
10845     }
10846   }
10847
10848   jresult = new Dali::Radian((const Dali::Radian &)result);
10849   return jresult;
10850 }
10851
10852
10853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10854   void * jresult ;
10855   Dali::Radian arg1 ;
10856   float arg2 ;
10857   float arg3 ;
10858   Dali::Radian *argp1 ;
10859   Dali::Radian result;
10860
10861   argp1 = (Dali::Radian *)jarg1;
10862   if (!argp1) {
10863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10864     return 0;
10865   }
10866   arg1 = *argp1;
10867   arg2 = (float)jarg2;
10868   arg3 = (float)jarg3;
10869   {
10870     try {
10871       result = Dali::Clamp(arg1,arg2,arg3);
10872     } catch (std::out_of_range& e) {
10873       {
10874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10875       };
10876     } catch (std::exception& e) {
10877       {
10878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10879       };
10880     } catch (Dali::DaliException e) {
10881       {
10882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10883       };
10884     } catch (...) {
10885       {
10886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10887       };
10888     }
10889   }
10890
10891   jresult = new Dali::Radian((const Dali::Radian &)result);
10892   return jresult;
10893 }
10894
10895
10896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10897   void * jresult ;
10898   Dali::Quaternion *result = 0 ;
10899
10900   {
10901     try {
10902       result = (Dali::Quaternion *)new Dali::Quaternion();
10903     } catch (std::out_of_range& e) {
10904       {
10905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10906       };
10907     } catch (std::exception& e) {
10908       {
10909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10910       };
10911     } catch (Dali::DaliException e) {
10912       {
10913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10914       };
10915     } catch (...) {
10916       {
10917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10918       };
10919     }
10920   }
10921
10922   jresult = (void *)result;
10923   return jresult;
10924 }
10925
10926
10927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10928   void * jresult ;
10929   Dali::Radian arg1 ;
10930   Dali::Vector3 *arg2 = 0 ;
10931   Dali::Radian *argp1 ;
10932   Dali::Quaternion *result = 0 ;
10933
10934   argp1 = (Dali::Radian *)jarg1;
10935   if (!argp1) {
10936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10937     return 0;
10938   }
10939   arg1 = *argp1;
10940   arg2 = (Dali::Vector3 *)jarg2;
10941   if (!arg2) {
10942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10943     return 0;
10944   }
10945   {
10946     try {
10947       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10948     } catch (std::out_of_range& e) {
10949       {
10950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10951       };
10952     } catch (std::exception& e) {
10953       {
10954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10955       };
10956     } catch (Dali::DaliException e) {
10957       {
10958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10959       };
10960     } catch (...) {
10961       {
10962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10963       };
10964     }
10965   }
10966
10967   jresult = (void *)result;
10968   return jresult;
10969 }
10970
10971
10972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10973   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10974
10975   arg1 = (Dali::Quaternion *)jarg1;
10976   {
10977     try {
10978       delete arg1;
10979     } catch (std::out_of_range& e) {
10980       {
10981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10982       };
10983     } catch (std::exception& e) {
10984       {
10985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10986       };
10987     } catch (Dali::DaliException e) {
10988       {
10989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10990       };
10991     } catch (...) {
10992       {
10993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10994       };
10995     }
10996   }
10997
10998 }
10999
11000
11001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
11002   void * jresult ;
11003   Dali::Quaternion *result = 0 ;
11004
11005   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11006   jresult = (void *)result;
11007   return jresult;
11008 }
11009
11010
11011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11012   unsigned int jresult ;
11013   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11014   bool result;
11015
11016   arg1 = (Dali::Quaternion *)jarg1;
11017   {
11018     try {
11019       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11020     } catch (std::out_of_range& e) {
11021       {
11022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11023       };
11024     } catch (std::exception& e) {
11025       {
11026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11027       };
11028     } catch (Dali::DaliException e) {
11029       {
11030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11031       };
11032     } catch (...) {
11033       {
11034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11035       };
11036     }
11037   }
11038
11039   jresult = result;
11040   return jresult;
11041 }
11042
11043
11044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11045   unsigned int jresult ;
11046   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11047   Dali::Vector3 *arg2 = 0 ;
11048   Dali::Radian *arg3 = 0 ;
11049   bool result;
11050
11051   arg1 = (Dali::Quaternion *)jarg1;
11052   arg2 = (Dali::Vector3 *)jarg2;
11053   if (!arg2) {
11054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11055     return 0;
11056   }
11057   arg3 = (Dali::Radian *)jarg3;
11058   if (!arg3) {
11059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11060     return 0;
11061   }
11062   {
11063     try {
11064       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11065     } catch (std::out_of_range& e) {
11066       {
11067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11068       };
11069     } catch (std::exception& e) {
11070       {
11071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11072       };
11073     } catch (Dali::DaliException e) {
11074       {
11075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11076       };
11077     } catch (...) {
11078       {
11079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11080       };
11081     }
11082   }
11083
11084   jresult = result;
11085   return jresult;
11086 }
11087
11088
11089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11090   void * jresult ;
11091   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11092   Dali::Quaternion *arg2 = 0 ;
11093   Dali::Quaternion result;
11094
11095   arg1 = (Dali::Quaternion *)jarg1;
11096   arg2 = (Dali::Quaternion *)jarg2;
11097   if (!arg2) {
11098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11099     return 0;
11100   }
11101   {
11102     try {
11103       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11104     } catch (std::out_of_range& e) {
11105       {
11106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11107       };
11108     } catch (std::exception& e) {
11109       {
11110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11111       };
11112     } catch (Dali::DaliException e) {
11113       {
11114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11115       };
11116     } catch (...) {
11117       {
11118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11119       };
11120     }
11121   }
11122
11123   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11124   return jresult;
11125 }
11126
11127
11128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11129   void * jresult ;
11130   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11131   Dali::Quaternion *arg2 = 0 ;
11132   Dali::Quaternion result;
11133
11134   arg1 = (Dali::Quaternion *)jarg1;
11135   arg2 = (Dali::Quaternion *)jarg2;
11136   if (!arg2) {
11137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11138     return 0;
11139   }
11140   {
11141     try {
11142       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11143     } catch (std::out_of_range& e) {
11144       {
11145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11146       };
11147     } catch (std::exception& e) {
11148       {
11149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11150       };
11151     } catch (Dali::DaliException e) {
11152       {
11153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11154       };
11155     } catch (...) {
11156       {
11157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11158       };
11159     }
11160   }
11161
11162   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11163   return jresult;
11164 }
11165
11166
11167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11168   void * jresult ;
11169   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11170   Dali::Quaternion *arg2 = 0 ;
11171   Dali::Quaternion result;
11172
11173   arg1 = (Dali::Quaternion *)jarg1;
11174   arg2 = (Dali::Quaternion *)jarg2;
11175   if (!arg2) {
11176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11177     return 0;
11178   }
11179   {
11180     try {
11181       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11182     } catch (std::out_of_range& e) {
11183       {
11184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11185       };
11186     } catch (std::exception& e) {
11187       {
11188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11189       };
11190     } catch (Dali::DaliException e) {
11191       {
11192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11193       };
11194     } catch (...) {
11195       {
11196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11197       };
11198     }
11199   }
11200
11201   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11202   return jresult;
11203 }
11204
11205
11206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11207   void * jresult ;
11208   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11209   Dali::Vector3 *arg2 = 0 ;
11210   Dali::Vector3 result;
11211
11212   arg1 = (Dali::Quaternion *)jarg1;
11213   arg2 = (Dali::Vector3 *)jarg2;
11214   if (!arg2) {
11215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11216     return 0;
11217   }
11218   {
11219     try {
11220       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11221     } catch (std::out_of_range& e) {
11222       {
11223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11224       };
11225     } catch (std::exception& e) {
11226       {
11227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11228       };
11229     } catch (Dali::DaliException e) {
11230       {
11231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11232       };
11233     } catch (...) {
11234       {
11235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11236       };
11237     }
11238   }
11239
11240   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11241   return jresult;
11242 }
11243
11244
11245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11246   void * jresult ;
11247   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11248   Dali::Quaternion *arg2 = 0 ;
11249   Dali::Quaternion result;
11250
11251   arg1 = (Dali::Quaternion *)jarg1;
11252   arg2 = (Dali::Quaternion *)jarg2;
11253   if (!arg2) {
11254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11255     return 0;
11256   }
11257   {
11258     try {
11259       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11260     } catch (std::out_of_range& e) {
11261       {
11262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11263       };
11264     } catch (std::exception& e) {
11265       {
11266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11267       };
11268     } catch (Dali::DaliException e) {
11269       {
11270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11271       };
11272     } catch (...) {
11273       {
11274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11275       };
11276     }
11277   }
11278
11279   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11280   return jresult;
11281 }
11282
11283
11284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11285   void * jresult ;
11286   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11287   float arg2 ;
11288   Dali::Quaternion result;
11289
11290   arg1 = (Dali::Quaternion *)jarg1;
11291   arg2 = (float)jarg2;
11292   {
11293     try {
11294       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11295     } catch (std::out_of_range& e) {
11296       {
11297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11298       };
11299     } catch (std::exception& e) {
11300       {
11301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11302       };
11303     } catch (Dali::DaliException e) {
11304       {
11305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11306       };
11307     } catch (...) {
11308       {
11309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11310       };
11311     }
11312   }
11313
11314   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11315   return jresult;
11316 }
11317
11318
11319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11320   void * jresult ;
11321   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11322   float arg2 ;
11323   Dali::Quaternion result;
11324
11325   arg1 = (Dali::Quaternion *)jarg1;
11326   arg2 = (float)jarg2;
11327   {
11328     try {
11329       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11330     } catch (std::out_of_range& e) {
11331       {
11332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11333       };
11334     } catch (std::exception& e) {
11335       {
11336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11337       };
11338     } catch (Dali::DaliException e) {
11339       {
11340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11341       };
11342     } catch (...) {
11343       {
11344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11345       };
11346     }
11347   }
11348
11349   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11350   return jresult;
11351 }
11352
11353
11354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11355   void * jresult ;
11356   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11357   Dali::Quaternion result;
11358
11359   arg1 = (Dali::Quaternion *)jarg1;
11360   {
11361     try {
11362       result = ((Dali::Quaternion const *)arg1)->operator -();
11363     } catch (std::out_of_range& e) {
11364       {
11365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11366       };
11367     } catch (std::exception& e) {
11368       {
11369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11370       };
11371     } catch (Dali::DaliException e) {
11372       {
11373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11374       };
11375     } catch (...) {
11376       {
11377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11378       };
11379     }
11380   }
11381
11382   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11383   return jresult;
11384 }
11385
11386
11387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11388   void * jresult ;
11389   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11390   Dali::Quaternion *arg2 = 0 ;
11391   Dali::Quaternion *result = 0 ;
11392
11393   arg1 = (Dali::Quaternion *)jarg1;
11394   arg2 = (Dali::Quaternion *)jarg2;
11395   if (!arg2) {
11396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11397     return 0;
11398   }
11399   {
11400     try {
11401       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11402     } catch (std::out_of_range& e) {
11403       {
11404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11405       };
11406     } catch (std::exception& e) {
11407       {
11408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11409       };
11410     } catch (Dali::DaliException e) {
11411       {
11412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11413       };
11414     } catch (...) {
11415       {
11416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11417       };
11418     }
11419   }
11420
11421   jresult = (void *)result;
11422   return jresult;
11423 }
11424
11425
11426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11427   void * jresult ;
11428   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11429   Dali::Quaternion *arg2 = 0 ;
11430   Dali::Quaternion *result = 0 ;
11431
11432   arg1 = (Dali::Quaternion *)jarg1;
11433   arg2 = (Dali::Quaternion *)jarg2;
11434   if (!arg2) {
11435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11436     return 0;
11437   }
11438   {
11439     try {
11440       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11441     } catch (std::out_of_range& e) {
11442       {
11443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11444       };
11445     } catch (std::exception& e) {
11446       {
11447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11448       };
11449     } catch (Dali::DaliException e) {
11450       {
11451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11452       };
11453     } catch (...) {
11454       {
11455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11456       };
11457     }
11458   }
11459
11460   jresult = (void *)result;
11461   return jresult;
11462 }
11463
11464
11465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11466   void * jresult ;
11467   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11468   Dali::Quaternion *arg2 = 0 ;
11469   Dali::Quaternion *result = 0 ;
11470
11471   arg1 = (Dali::Quaternion *)jarg1;
11472   arg2 = (Dali::Quaternion *)jarg2;
11473   if (!arg2) {
11474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11475     return 0;
11476   }
11477   {
11478     try {
11479       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11480     } catch (std::out_of_range& e) {
11481       {
11482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11483       };
11484     } catch (std::exception& e) {
11485       {
11486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11487       };
11488     } catch (Dali::DaliException e) {
11489       {
11490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11491       };
11492     } catch (...) {
11493       {
11494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11495       };
11496     }
11497   }
11498
11499   jresult = (void *)result;
11500   return jresult;
11501 }
11502
11503
11504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11505   void * jresult ;
11506   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11507   float arg2 ;
11508   Dali::Quaternion *result = 0 ;
11509
11510   arg1 = (Dali::Quaternion *)jarg1;
11511   arg2 = (float)jarg2;
11512   {
11513     try {
11514       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11515     } catch (std::out_of_range& e) {
11516       {
11517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11518       };
11519     } catch (std::exception& e) {
11520       {
11521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11522       };
11523     } catch (Dali::DaliException e) {
11524       {
11525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11526       };
11527     } catch (...) {
11528       {
11529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11530       };
11531     }
11532   }
11533
11534   jresult = (void *)result;
11535   return jresult;
11536 }
11537
11538
11539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11540   void * jresult ;
11541   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11542   float arg2 ;
11543   Dali::Quaternion *result = 0 ;
11544
11545   arg1 = (Dali::Quaternion *)jarg1;
11546   arg2 = (float)jarg2;
11547   {
11548     try {
11549       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11550     } catch (std::out_of_range& e) {
11551       {
11552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11553       };
11554     } catch (std::exception& e) {
11555       {
11556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11557       };
11558     } catch (Dali::DaliException e) {
11559       {
11560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11561       };
11562     } catch (...) {
11563       {
11564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11565       };
11566     }
11567   }
11568
11569   jresult = (void *)result;
11570   return jresult;
11571 }
11572
11573
11574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11575   unsigned int jresult ;
11576   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11577   Dali::Quaternion *arg2 = 0 ;
11578   bool result;
11579
11580   arg1 = (Dali::Quaternion *)jarg1;
11581   arg2 = (Dali::Quaternion *)jarg2;
11582   if (!arg2) {
11583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11584     return 0;
11585   }
11586   {
11587     try {
11588       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11589     } catch (std::out_of_range& e) {
11590       {
11591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11592       };
11593     } catch (std::exception& e) {
11594       {
11595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11596       };
11597     } catch (Dali::DaliException e) {
11598       {
11599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11600       };
11601     } catch (...) {
11602       {
11603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11604       };
11605     }
11606   }
11607
11608   jresult = result;
11609   return jresult;
11610 }
11611
11612
11613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11614   unsigned int jresult ;
11615   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11616   Dali::Quaternion *arg2 = 0 ;
11617   bool result;
11618
11619   arg1 = (Dali::Quaternion *)jarg1;
11620   arg2 = (Dali::Quaternion *)jarg2;
11621   if (!arg2) {
11622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11623     return 0;
11624   }
11625   {
11626     try {
11627       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11628     } catch (std::out_of_range& e) {
11629       {
11630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11631       };
11632     } catch (std::exception& e) {
11633       {
11634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11635       };
11636     } catch (Dali::DaliException e) {
11637       {
11638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11639       };
11640     } catch (...) {
11641       {
11642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11643       };
11644     }
11645   }
11646
11647   jresult = result;
11648   return jresult;
11649 }
11650
11651
11652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11653   float jresult ;
11654   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11655   float result;
11656
11657   arg1 = (Dali::Quaternion *)jarg1;
11658   {
11659     try {
11660       result = (float)((Dali::Quaternion const *)arg1)->Length();
11661     } catch (std::out_of_range& e) {
11662       {
11663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11664       };
11665     } catch (std::exception& e) {
11666       {
11667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11668       };
11669     } catch (Dali::DaliException e) {
11670       {
11671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11672       };
11673     } catch (...) {
11674       {
11675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11676       };
11677     }
11678   }
11679
11680   jresult = result;
11681   return jresult;
11682 }
11683
11684
11685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11686   float jresult ;
11687   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11688   float result;
11689
11690   arg1 = (Dali::Quaternion *)jarg1;
11691   {
11692     try {
11693       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11694     } catch (std::out_of_range& e) {
11695       {
11696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11697       };
11698     } catch (std::exception& e) {
11699       {
11700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11701       };
11702     } catch (Dali::DaliException e) {
11703       {
11704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11705       };
11706     } catch (...) {
11707       {
11708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11709       };
11710     }
11711   }
11712
11713   jresult = result;
11714   return jresult;
11715 }
11716
11717
11718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11719   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11720
11721   arg1 = (Dali::Quaternion *)jarg1;
11722   {
11723     try {
11724       (arg1)->Normalize();
11725     } catch (std::out_of_range& e) {
11726       {
11727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11728       };
11729     } catch (std::exception& e) {
11730       {
11731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11732       };
11733     } catch (Dali::DaliException e) {
11734       {
11735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11736       };
11737     } catch (...) {
11738       {
11739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11740       };
11741     }
11742   }
11743
11744 }
11745
11746
11747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11748   void * jresult ;
11749   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11750   Dali::Quaternion result;
11751
11752   arg1 = (Dali::Quaternion *)jarg1;
11753   {
11754     try {
11755       result = ((Dali::Quaternion const *)arg1)->Normalized();
11756     } catch (std::out_of_range& e) {
11757       {
11758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11759       };
11760     } catch (std::exception& e) {
11761       {
11762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11763       };
11764     } catch (Dali::DaliException e) {
11765       {
11766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11767       };
11768     } catch (...) {
11769       {
11770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11771       };
11772     }
11773   }
11774
11775   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11776   return jresult;
11777 }
11778
11779
11780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11781   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11782
11783   arg1 = (Dali::Quaternion *)jarg1;
11784   {
11785     try {
11786       (arg1)->Conjugate();
11787     } catch (std::out_of_range& e) {
11788       {
11789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11790       };
11791     } catch (std::exception& e) {
11792       {
11793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11794       };
11795     } catch (Dali::DaliException e) {
11796       {
11797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11798       };
11799     } catch (...) {
11800       {
11801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11802       };
11803     }
11804   }
11805
11806 }
11807
11808
11809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11810   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11811
11812   arg1 = (Dali::Quaternion *)jarg1;
11813   {
11814     try {
11815       (arg1)->Invert();
11816     } catch (std::out_of_range& e) {
11817       {
11818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11819       };
11820     } catch (std::exception& e) {
11821       {
11822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11823       };
11824     } catch (Dali::DaliException e) {
11825       {
11826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11827       };
11828     } catch (...) {
11829       {
11830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11831       };
11832     }
11833   }
11834
11835 }
11836
11837
11838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11839   void * jresult ;
11840   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11841   Dali::Quaternion result;
11842
11843   arg1 = (Dali::Quaternion *)jarg1;
11844   {
11845     try {
11846       result = ((Dali::Quaternion const *)arg1)->Log();
11847     } catch (std::out_of_range& e) {
11848       {
11849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11850       };
11851     } catch (std::exception& e) {
11852       {
11853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11854       };
11855     } catch (Dali::DaliException e) {
11856       {
11857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11858       };
11859     } catch (...) {
11860       {
11861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11862       };
11863     }
11864   }
11865
11866   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11867   return jresult;
11868 }
11869
11870
11871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11872   void * jresult ;
11873   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11874   Dali::Quaternion result;
11875
11876   arg1 = (Dali::Quaternion *)jarg1;
11877   {
11878     try {
11879       result = ((Dali::Quaternion const *)arg1)->Exp();
11880     } catch (std::out_of_range& e) {
11881       {
11882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11883       };
11884     } catch (std::exception& e) {
11885       {
11886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11887       };
11888     } catch (Dali::DaliException e) {
11889       {
11890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11891       };
11892     } catch (...) {
11893       {
11894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11895       };
11896     }
11897   }
11898
11899   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11900   return jresult;
11901 }
11902
11903
11904 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11905   float jresult ;
11906   Dali::Quaternion *arg1 = 0 ;
11907   Dali::Quaternion *arg2 = 0 ;
11908   float result;
11909
11910   arg1 = (Dali::Quaternion *)jarg1;
11911   if (!arg1) {
11912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11913     return 0;
11914   }
11915   arg2 = (Dali::Quaternion *)jarg2;
11916   if (!arg2) {
11917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11918     return 0;
11919   }
11920   {
11921     try {
11922       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11923     } catch (std::out_of_range& e) {
11924       {
11925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11926       };
11927     } catch (std::exception& e) {
11928       {
11929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11930       };
11931     } catch (Dali::DaliException e) {
11932       {
11933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11934       };
11935     } catch (...) {
11936       {
11937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11938       };
11939     }
11940   }
11941
11942   jresult = result;
11943   return jresult;
11944 }
11945
11946
11947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11948   void * jresult ;
11949   Dali::Quaternion *arg1 = 0 ;
11950   Dali::Quaternion *arg2 = 0 ;
11951   float arg3 ;
11952   Dali::Quaternion result;
11953
11954   arg1 = (Dali::Quaternion *)jarg1;
11955   if (!arg1) {
11956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11957     return 0;
11958   }
11959   arg2 = (Dali::Quaternion *)jarg2;
11960   if (!arg2) {
11961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11962     return 0;
11963   }
11964   arg3 = (float)jarg3;
11965   {
11966     try {
11967       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11968     } catch (std::out_of_range& e) {
11969       {
11970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11971       };
11972     } catch (std::exception& e) {
11973       {
11974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11975       };
11976     } catch (Dali::DaliException e) {
11977       {
11978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11979       };
11980     } catch (...) {
11981       {
11982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11983       };
11984     }
11985   }
11986
11987   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11988   return jresult;
11989 }
11990
11991
11992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11993   void * jresult ;
11994   Dali::Quaternion *arg1 = 0 ;
11995   Dali::Quaternion *arg2 = 0 ;
11996   float arg3 ;
11997   Dali::Quaternion result;
11998
11999   arg1 = (Dali::Quaternion *)jarg1;
12000   if (!arg1) {
12001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12002     return 0;
12003   }
12004   arg2 = (Dali::Quaternion *)jarg2;
12005   if (!arg2) {
12006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12007     return 0;
12008   }
12009   arg3 = (float)jarg3;
12010   {
12011     try {
12012       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12013     } catch (std::out_of_range& e) {
12014       {
12015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12016       };
12017     } catch (std::exception& e) {
12018       {
12019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12020       };
12021     } catch (Dali::DaliException e) {
12022       {
12023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12024       };
12025     } catch (...) {
12026       {
12027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12028       };
12029     }
12030   }
12031
12032   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12033   return jresult;
12034 }
12035
12036
12037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12038   void * jresult ;
12039   Dali::Quaternion *arg1 = 0 ;
12040   Dali::Quaternion *arg2 = 0 ;
12041   float arg3 ;
12042   Dali::Quaternion result;
12043
12044   arg1 = (Dali::Quaternion *)jarg1;
12045   if (!arg1) {
12046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12047     return 0;
12048   }
12049   arg2 = (Dali::Quaternion *)jarg2;
12050   if (!arg2) {
12051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12052     return 0;
12053   }
12054   arg3 = (float)jarg3;
12055   {
12056     try {
12057       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12058     } catch (std::out_of_range& e) {
12059       {
12060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12061       };
12062     } catch (std::exception& e) {
12063       {
12064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12065       };
12066     } catch (Dali::DaliException e) {
12067       {
12068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12069       };
12070     } catch (...) {
12071       {
12072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12073       };
12074     }
12075   }
12076
12077   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12078   return jresult;
12079 }
12080
12081
12082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12083   void * jresult ;
12084   Dali::Quaternion *arg1 = 0 ;
12085   Dali::Quaternion *arg2 = 0 ;
12086   Dali::Quaternion *arg3 = 0 ;
12087   Dali::Quaternion *arg4 = 0 ;
12088   float arg5 ;
12089   Dali::Quaternion result;
12090
12091   arg1 = (Dali::Quaternion *)jarg1;
12092   if (!arg1) {
12093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12094     return 0;
12095   }
12096   arg2 = (Dali::Quaternion *)jarg2;
12097   if (!arg2) {
12098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12099     return 0;
12100   }
12101   arg3 = (Dali::Quaternion *)jarg3;
12102   if (!arg3) {
12103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12104     return 0;
12105   }
12106   arg4 = (Dali::Quaternion *)jarg4;
12107   if (!arg4) {
12108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12109     return 0;
12110   }
12111   arg5 = (float)jarg5;
12112   {
12113     try {
12114       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12115     } catch (std::out_of_range& e) {
12116       {
12117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12118       };
12119     } catch (std::exception& e) {
12120       {
12121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12122       };
12123     } catch (Dali::DaliException e) {
12124       {
12125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12126       };
12127     } catch (...) {
12128       {
12129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12130       };
12131     }
12132   }
12133
12134   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12135   return jresult;
12136 }
12137
12138
12139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12140   float jresult ;
12141   Dali::Quaternion *arg1 = 0 ;
12142   Dali::Quaternion *arg2 = 0 ;
12143   float result;
12144
12145   arg1 = (Dali::Quaternion *)jarg1;
12146   if (!arg1) {
12147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12148     return 0;
12149   }
12150   arg2 = (Dali::Quaternion *)jarg2;
12151   if (!arg2) {
12152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12153     return 0;
12154   }
12155   {
12156     try {
12157       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12158     } catch (std::out_of_range& e) {
12159       {
12160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12161       };
12162     } catch (std::exception& e) {
12163       {
12164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12165       };
12166     } catch (Dali::DaliException e) {
12167       {
12168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12169       };
12170     } catch (...) {
12171       {
12172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12173       };
12174     }
12175   }
12176
12177   jresult = result;
12178   return jresult;
12179 }
12180
12181
12182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12183   void * jresult ;
12184   Dali::Matrix *result = 0 ;
12185
12186   {
12187     try {
12188       result = (Dali::Matrix *)new Dali::Matrix();
12189     } catch (std::out_of_range& e) {
12190       {
12191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12192       };
12193     } catch (std::exception& e) {
12194       {
12195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12196       };
12197     } catch (Dali::DaliException e) {
12198       {
12199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12200       };
12201     } catch (...) {
12202       {
12203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12204       };
12205     }
12206   }
12207
12208   jresult = (void *)result;
12209   return jresult;
12210 }
12211
12212
12213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12214   void * jresult ;
12215   bool arg1 ;
12216   Dali::Matrix *result = 0 ;
12217
12218   arg1 = jarg1 ? true : false;
12219   {
12220     try {
12221       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12222     } catch (std::out_of_range& e) {
12223       {
12224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12225       };
12226     } catch (std::exception& e) {
12227       {
12228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12229       };
12230     } catch (Dali::DaliException e) {
12231       {
12232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12233       };
12234     } catch (...) {
12235       {
12236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12237       };
12238     }
12239   }
12240
12241   jresult = (void *)result;
12242   return jresult;
12243 }
12244
12245
12246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12247   void * jresult ;
12248   float *arg1 = (float *) 0 ;
12249   Dali::Matrix *result = 0 ;
12250
12251   arg1 = jarg1;
12252   {
12253     try {
12254       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12255     } catch (std::out_of_range& e) {
12256       {
12257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12258       };
12259     } catch (std::exception& e) {
12260       {
12261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12262       };
12263     } catch (Dali::DaliException e) {
12264       {
12265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12266       };
12267     } catch (...) {
12268       {
12269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12270       };
12271     }
12272   }
12273
12274   jresult = (void *)result;
12275
12276
12277   return jresult;
12278 }
12279
12280
12281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12282   void * jresult ;
12283   Dali::Quaternion *arg1 = 0 ;
12284   Dali::Matrix *result = 0 ;
12285
12286   arg1 = (Dali::Quaternion *)jarg1;
12287   if (!arg1) {
12288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12289     return 0;
12290   }
12291   {
12292     try {
12293       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12294     } catch (std::out_of_range& e) {
12295       {
12296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12297       };
12298     } catch (std::exception& e) {
12299       {
12300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12301       };
12302     } catch (Dali::DaliException e) {
12303       {
12304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12305       };
12306     } catch (...) {
12307       {
12308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12309       };
12310     }
12311   }
12312
12313   jresult = (void *)result;
12314   return jresult;
12315 }
12316
12317
12318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12319   void * jresult ;
12320   Dali::Matrix *arg1 = 0 ;
12321   Dali::Matrix *result = 0 ;
12322
12323   arg1 = (Dali::Matrix *)jarg1;
12324   if (!arg1) {
12325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12326     return 0;
12327   }
12328   {
12329     try {
12330       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12331     } catch (std::out_of_range& e) {
12332       {
12333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12334       };
12335     } catch (std::exception& e) {
12336       {
12337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12338       };
12339     } catch (Dali::DaliException e) {
12340       {
12341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12342       };
12343     } catch (...) {
12344       {
12345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12346       };
12347     }
12348   }
12349
12350   jresult = (void *)result;
12351   return jresult;
12352 }
12353
12354
12355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12356   void * jresult ;
12357   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12358   Dali::Matrix *arg2 = 0 ;
12359   Dali::Matrix *result = 0 ;
12360
12361   arg1 = (Dali::Matrix *)jarg1;
12362   arg2 = (Dali::Matrix *)jarg2;
12363   if (!arg2) {
12364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12365     return 0;
12366   }
12367   {
12368     try {
12369       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12370     } catch (std::out_of_range& e) {
12371       {
12372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12373       };
12374     } catch (std::exception& e) {
12375       {
12376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12377       };
12378     } catch (Dali::DaliException e) {
12379       {
12380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12381       };
12382     } catch (...) {
12383       {
12384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12385       };
12386     }
12387   }
12388
12389   jresult = (void *)result;
12390   return jresult;
12391 }
12392
12393
12394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12395   void * jresult ;
12396   Dali::Matrix *result = 0 ;
12397
12398   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12399   jresult = (void *)result;
12400   return jresult;
12401 }
12402
12403
12404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12405   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12406
12407   arg1 = (Dali::Matrix *)jarg1;
12408   {
12409     try {
12410       (arg1)->SetIdentity();
12411     } catch (std::out_of_range& e) {
12412       {
12413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12414       };
12415     } catch (std::exception& e) {
12416       {
12417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12418       };
12419     } catch (Dali::DaliException e) {
12420       {
12421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12422       };
12423     } catch (...) {
12424       {
12425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12426       };
12427     }
12428   }
12429
12430 }
12431
12432
12433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12434   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12435   Dali::Vector3 *arg2 = 0 ;
12436
12437   arg1 = (Dali::Matrix *)jarg1;
12438   arg2 = (Dali::Vector3 *)jarg2;
12439   if (!arg2) {
12440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12441     return ;
12442   }
12443   {
12444     try {
12445       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12446     } catch (std::out_of_range& e) {
12447       {
12448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12449       };
12450     } catch (std::exception& e) {
12451       {
12452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12453       };
12454     } catch (Dali::DaliException e) {
12455       {
12456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12457       };
12458     } catch (...) {
12459       {
12460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12461       };
12462     }
12463   }
12464
12465 }
12466
12467
12468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12469   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12470   Dali::Matrix *arg2 = 0 ;
12471
12472   arg1 = (Dali::Matrix *)jarg1;
12473   arg2 = (Dali::Matrix *)jarg2;
12474   if (!arg2) {
12475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12476     return ;
12477   }
12478   {
12479     try {
12480       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12481     } catch (std::out_of_range& e) {
12482       {
12483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12484       };
12485     } catch (std::exception& e) {
12486       {
12487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12488       };
12489     } catch (Dali::DaliException e) {
12490       {
12491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12492       };
12493     } catch (...) {
12494       {
12495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12496       };
12497     }
12498   }
12499
12500 }
12501
12502
12503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12504   unsigned int jresult ;
12505   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12506   bool result;
12507
12508   arg1 = (Dali::Matrix *)jarg1;
12509   {
12510     try {
12511       result = (bool)(arg1)->Invert();
12512     } catch (std::out_of_range& e) {
12513       {
12514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12515       };
12516     } catch (std::exception& e) {
12517       {
12518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12519       };
12520     } catch (Dali::DaliException e) {
12521       {
12522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12523       };
12524     } catch (...) {
12525       {
12526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12527       };
12528     }
12529   }
12530
12531   jresult = result;
12532   return jresult;
12533 }
12534
12535
12536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12537   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12538
12539   arg1 = (Dali::Matrix *)jarg1;
12540   {
12541     try {
12542       (arg1)->Transpose();
12543     } catch (std::out_of_range& e) {
12544       {
12545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12546       };
12547     } catch (std::exception& e) {
12548       {
12549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12550       };
12551     } catch (Dali::DaliException e) {
12552       {
12553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12554       };
12555     } catch (...) {
12556       {
12557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12558       };
12559     }
12560   }
12561
12562 }
12563
12564
12565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12566   void * jresult ;
12567   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12568   Dali::Vector3 result;
12569
12570   arg1 = (Dali::Matrix *)jarg1;
12571   {
12572     try {
12573       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12574     } catch (std::out_of_range& e) {
12575       {
12576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12577       };
12578     } catch (std::exception& e) {
12579       {
12580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12581       };
12582     } catch (Dali::DaliException e) {
12583       {
12584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12585       };
12586     } catch (...) {
12587       {
12588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12589       };
12590     }
12591   }
12592
12593   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12594   return jresult;
12595 }
12596
12597
12598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12599   void * jresult ;
12600   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12601   Dali::Vector3 result;
12602
12603   arg1 = (Dali::Matrix *)jarg1;
12604   {
12605     try {
12606       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12607     } catch (std::out_of_range& e) {
12608       {
12609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12610       };
12611     } catch (std::exception& e) {
12612       {
12613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12614       };
12615     } catch (Dali::DaliException e) {
12616       {
12617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12618       };
12619     } catch (...) {
12620       {
12621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12622       };
12623     }
12624   }
12625
12626   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12627   return jresult;
12628 }
12629
12630
12631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12632   void * jresult ;
12633   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12634   Dali::Vector3 result;
12635
12636   arg1 = (Dali::Matrix *)jarg1;
12637   {
12638     try {
12639       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12640     } catch (std::out_of_range& e) {
12641       {
12642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12643       };
12644     } catch (std::exception& e) {
12645       {
12646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12647       };
12648     } catch (Dali::DaliException e) {
12649       {
12650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12651       };
12652     } catch (...) {
12653       {
12654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12655       };
12656     }
12657   }
12658
12659   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12660   return jresult;
12661 }
12662
12663
12664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12665   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12666   Dali::Vector3 *arg2 = 0 ;
12667
12668   arg1 = (Dali::Matrix *)jarg1;
12669   arg2 = (Dali::Vector3 *)jarg2;
12670   if (!arg2) {
12671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12672     return ;
12673   }
12674   {
12675     try {
12676       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12677     } catch (std::out_of_range& e) {
12678       {
12679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12680       };
12681     } catch (std::exception& e) {
12682       {
12683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12684       };
12685     } catch (Dali::DaliException e) {
12686       {
12687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12688       };
12689     } catch (...) {
12690       {
12691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12692       };
12693     }
12694   }
12695
12696 }
12697
12698
12699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12700   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12701   Dali::Vector3 *arg2 = 0 ;
12702
12703   arg1 = (Dali::Matrix *)jarg1;
12704   arg2 = (Dali::Vector3 *)jarg2;
12705   if (!arg2) {
12706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12707     return ;
12708   }
12709   {
12710     try {
12711       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12712     } catch (std::out_of_range& e) {
12713       {
12714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12715       };
12716     } catch (std::exception& e) {
12717       {
12718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12719       };
12720     } catch (Dali::DaliException e) {
12721       {
12722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12723       };
12724     } catch (...) {
12725       {
12726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12727       };
12728     }
12729   }
12730
12731 }
12732
12733
12734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12735   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12736   Dali::Vector3 *arg2 = 0 ;
12737
12738   arg1 = (Dali::Matrix *)jarg1;
12739   arg2 = (Dali::Vector3 *)jarg2;
12740   if (!arg2) {
12741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12742     return ;
12743   }
12744   {
12745     try {
12746       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12747     } catch (std::out_of_range& e) {
12748       {
12749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12750       };
12751     } catch (std::exception& e) {
12752       {
12753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12754       };
12755     } catch (Dali::DaliException e) {
12756       {
12757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12758       };
12759     } catch (...) {
12760       {
12761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12762       };
12763     }
12764   }
12765
12766 }
12767
12768
12769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12770   void * jresult ;
12771   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12772   Dali::Vector4 *result = 0 ;
12773
12774   arg1 = (Dali::Matrix *)jarg1;
12775   {
12776     try {
12777       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12778     } catch (std::out_of_range& e) {
12779       {
12780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12781       };
12782     } catch (std::exception& e) {
12783       {
12784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12785       };
12786     } catch (Dali::DaliException e) {
12787       {
12788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12789       };
12790     } catch (...) {
12791       {
12792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12793       };
12794     }
12795   }
12796
12797   jresult = (void *)result;
12798   return jresult;
12799 }
12800
12801
12802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12803   void * jresult ;
12804   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12805   Dali::Vector3 *result = 0 ;
12806
12807   arg1 = (Dali::Matrix *)jarg1;
12808   {
12809     try {
12810       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12811     } catch (std::out_of_range& e) {
12812       {
12813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12814       };
12815     } catch (std::exception& e) {
12816       {
12817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12818       };
12819     } catch (Dali::DaliException e) {
12820       {
12821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12822       };
12823     } catch (...) {
12824       {
12825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12826       };
12827     }
12828   }
12829
12830   jresult = (void *)result;
12831   return jresult;
12832 }
12833
12834
12835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12836   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12837   Dali::Vector4 *arg2 = 0 ;
12838
12839   arg1 = (Dali::Matrix *)jarg1;
12840   arg2 = (Dali::Vector4 *)jarg2;
12841   if (!arg2) {
12842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12843     return ;
12844   }
12845   {
12846     try {
12847       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12848     } catch (std::out_of_range& e) {
12849       {
12850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12851       };
12852     } catch (std::exception& e) {
12853       {
12854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12855       };
12856     } catch (Dali::DaliException e) {
12857       {
12858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12859       };
12860     } catch (...) {
12861       {
12862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12863       };
12864     }
12865   }
12866
12867 }
12868
12869
12870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12871   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12872   Dali::Vector3 *arg2 = 0 ;
12873
12874   arg1 = (Dali::Matrix *)jarg1;
12875   arg2 = (Dali::Vector3 *)jarg2;
12876   if (!arg2) {
12877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12878     return ;
12879   }
12880   {
12881     try {
12882       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12883     } catch (std::out_of_range& e) {
12884       {
12885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12886       };
12887     } catch (std::exception& e) {
12888       {
12889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12890       };
12891     } catch (Dali::DaliException e) {
12892       {
12893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12894       };
12895     } catch (...) {
12896       {
12897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12898       };
12899     }
12900   }
12901
12902 }
12903
12904
12905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12906   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12907
12908   arg1 = (Dali::Matrix *)jarg1;
12909   {
12910     try {
12911       (arg1)->OrthoNormalize();
12912     } catch (std::out_of_range& e) {
12913       {
12914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12915       };
12916     } catch (std::exception& e) {
12917       {
12918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12919       };
12920     } catch (Dali::DaliException e) {
12921       {
12922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12923       };
12924     } catch (...) {
12925       {
12926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12927       };
12928     }
12929   }
12930
12931 }
12932
12933
12934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12935   void * jresult ;
12936   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12937   float *result = 0 ;
12938
12939   arg1 = (Dali::Matrix *)jarg1;
12940   {
12941     try {
12942       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12943     } catch (std::out_of_range& e) {
12944       {
12945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12946       };
12947     } catch (std::exception& e) {
12948       {
12949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12950       };
12951     } catch (Dali::DaliException e) {
12952       {
12953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12954       };
12955     } catch (...) {
12956       {
12957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12958       };
12959     }
12960   }
12961
12962   jresult = (void *)result;
12963   return jresult;
12964 }
12965
12966
12967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12968   Dali::Matrix *arg1 = 0 ;
12969   Dali::Matrix *arg2 = 0 ;
12970   Dali::Matrix *arg3 = 0 ;
12971
12972   arg1 = (Dali::Matrix *)jarg1;
12973   if (!arg1) {
12974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12975     return ;
12976   }
12977   arg2 = (Dali::Matrix *)jarg2;
12978   if (!arg2) {
12979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12980     return ;
12981   }
12982   arg3 = (Dali::Matrix *)jarg3;
12983   if (!arg3) {
12984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12985     return ;
12986   }
12987   {
12988     try {
12989       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12990     } catch (std::out_of_range& e) {
12991       {
12992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12993       };
12994     } catch (std::exception& e) {
12995       {
12996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12997       };
12998     } catch (Dali::DaliException e) {
12999       {
13000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13001       };
13002     } catch (...) {
13003       {
13004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13005       };
13006     }
13007   }
13008
13009 }
13010
13011
13012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13013   Dali::Matrix *arg1 = 0 ;
13014   Dali::Matrix *arg2 = 0 ;
13015   Dali::Quaternion *arg3 = 0 ;
13016
13017   arg1 = (Dali::Matrix *)jarg1;
13018   if (!arg1) {
13019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13020     return ;
13021   }
13022   arg2 = (Dali::Matrix *)jarg2;
13023   if (!arg2) {
13024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13025     return ;
13026   }
13027   arg3 = (Dali::Quaternion *)jarg3;
13028   if (!arg3) {
13029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13030     return ;
13031   }
13032   {
13033     try {
13034       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13035     } catch (std::out_of_range& e) {
13036       {
13037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13038       };
13039     } catch (std::exception& e) {
13040       {
13041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13042       };
13043     } catch (Dali::DaliException e) {
13044       {
13045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13046       };
13047     } catch (...) {
13048       {
13049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13050       };
13051     }
13052   }
13053
13054 }
13055
13056
13057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13058   void * jresult ;
13059   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13060   Dali::Vector4 *arg2 = 0 ;
13061   Dali::Vector4 result;
13062
13063   arg1 = (Dali::Matrix *)jarg1;
13064   arg2 = (Dali::Vector4 *)jarg2;
13065   if (!arg2) {
13066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13067     return 0;
13068   }
13069   {
13070     try {
13071       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13072     } catch (std::out_of_range& e) {
13073       {
13074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13075       };
13076     } catch (std::exception& e) {
13077       {
13078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13079       };
13080     } catch (Dali::DaliException e) {
13081       {
13082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13083       };
13084     } catch (...) {
13085       {
13086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13087       };
13088     }
13089   }
13090
13091   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13092   return jresult;
13093 }
13094
13095
13096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13097   unsigned int jresult ;
13098   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13099   Dali::Matrix *arg2 = 0 ;
13100   bool result;
13101
13102   arg1 = (Dali::Matrix *)jarg1;
13103   arg2 = (Dali::Matrix *)jarg2;
13104   if (!arg2) {
13105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13106     return 0;
13107   }
13108   {
13109     try {
13110       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13111     } catch (std::out_of_range& e) {
13112       {
13113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13114       };
13115     } catch (std::exception& e) {
13116       {
13117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13118       };
13119     } catch (Dali::DaliException e) {
13120       {
13121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13122       };
13123     } catch (...) {
13124       {
13125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13126       };
13127     }
13128   }
13129
13130   jresult = result;
13131   return jresult;
13132 }
13133
13134
13135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13136   unsigned int jresult ;
13137   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13138   Dali::Matrix *arg2 = 0 ;
13139   bool result;
13140
13141   arg1 = (Dali::Matrix *)jarg1;
13142   arg2 = (Dali::Matrix *)jarg2;
13143   if (!arg2) {
13144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13145     return 0;
13146   }
13147   {
13148     try {
13149       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13150     } catch (std::out_of_range& e) {
13151       {
13152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13153       };
13154     } catch (std::exception& e) {
13155       {
13156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13157       };
13158     } catch (Dali::DaliException e) {
13159       {
13160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13161       };
13162     } catch (...) {
13163       {
13164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13165       };
13166     }
13167   }
13168
13169   jresult = result;
13170   return jresult;
13171 }
13172
13173
13174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13175   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13176   Dali::Vector3 *arg2 = 0 ;
13177   Dali::Quaternion *arg3 = 0 ;
13178   Dali::Vector3 *arg4 = 0 ;
13179
13180   arg1 = (Dali::Matrix *)jarg1;
13181   arg2 = (Dali::Vector3 *)jarg2;
13182   if (!arg2) {
13183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13184     return ;
13185   }
13186   arg3 = (Dali::Quaternion *)jarg3;
13187   if (!arg3) {
13188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13189     return ;
13190   }
13191   arg4 = (Dali::Vector3 *)jarg4;
13192   if (!arg4) {
13193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13194     return ;
13195   }
13196   {
13197     try {
13198       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13199     } catch (std::out_of_range& e) {
13200       {
13201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13202       };
13203     } catch (std::exception& e) {
13204       {
13205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13206       };
13207     } catch (Dali::DaliException e) {
13208       {
13209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13210       };
13211     } catch (...) {
13212       {
13213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13214       };
13215     }
13216   }
13217
13218 }
13219
13220
13221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13222   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13223   Dali::Vector3 *arg2 = 0 ;
13224   Dali::Quaternion *arg3 = 0 ;
13225   Dali::Vector3 *arg4 = 0 ;
13226
13227   arg1 = (Dali::Matrix *)jarg1;
13228   arg2 = (Dali::Vector3 *)jarg2;
13229   if (!arg2) {
13230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13231     return ;
13232   }
13233   arg3 = (Dali::Quaternion *)jarg3;
13234   if (!arg3) {
13235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13236     return ;
13237   }
13238   arg4 = (Dali::Vector3 *)jarg4;
13239   if (!arg4) {
13240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13241     return ;
13242   }
13243   {
13244     try {
13245       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13246     } catch (std::out_of_range& e) {
13247       {
13248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13249       };
13250     } catch (std::exception& e) {
13251       {
13252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13253       };
13254     } catch (Dali::DaliException e) {
13255       {
13256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13257       };
13258     } catch (...) {
13259       {
13260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13261       };
13262     }
13263   }
13264
13265 }
13266
13267
13268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13269   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13270   Dali::Vector3 *arg2 = 0 ;
13271   Dali::Vector3 *arg3 = 0 ;
13272   Dali::Vector3 *arg4 = 0 ;
13273   Dali::Vector3 *arg5 = 0 ;
13274
13275   arg1 = (Dali::Matrix *)jarg1;
13276   arg2 = (Dali::Vector3 *)jarg2;
13277   if (!arg2) {
13278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13279     return ;
13280   }
13281   arg3 = (Dali::Vector3 *)jarg3;
13282   if (!arg3) {
13283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13284     return ;
13285   }
13286   arg4 = (Dali::Vector3 *)jarg4;
13287   if (!arg4) {
13288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13289     return ;
13290   }
13291   arg5 = (Dali::Vector3 *)jarg5;
13292   if (!arg5) {
13293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13294     return ;
13295   }
13296   {
13297     try {
13298       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13299     } catch (std::out_of_range& e) {
13300       {
13301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13302       };
13303     } catch (std::exception& e) {
13304       {
13305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13306       };
13307     } catch (Dali::DaliException e) {
13308       {
13309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13310       };
13311     } catch (...) {
13312       {
13313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13314       };
13315     }
13316   }
13317
13318 }
13319
13320
13321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13322   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13323   Dali::Vector3 *arg2 = 0 ;
13324   Dali::Quaternion *arg3 = 0 ;
13325   Dali::Vector3 *arg4 = 0 ;
13326
13327   arg1 = (Dali::Matrix *)jarg1;
13328   arg2 = (Dali::Vector3 *)jarg2;
13329   if (!arg2) {
13330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13331     return ;
13332   }
13333   arg3 = (Dali::Quaternion *)jarg3;
13334   if (!arg3) {
13335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13336     return ;
13337   }
13338   arg4 = (Dali::Vector3 *)jarg4;
13339   if (!arg4) {
13340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13341     return ;
13342   }
13343   {
13344     try {
13345       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13346     } catch (std::out_of_range& e) {
13347       {
13348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13349       };
13350     } catch (std::exception& e) {
13351       {
13352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13353       };
13354     } catch (Dali::DaliException e) {
13355       {
13356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13357       };
13358     } catch (...) {
13359       {
13360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13361       };
13362     }
13363   }
13364
13365 }
13366
13367
13368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13369   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13370
13371   arg1 = (Dali::Matrix *)jarg1;
13372   {
13373     try {
13374       delete arg1;
13375     } catch (std::out_of_range& e) {
13376       {
13377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13378       };
13379     } catch (std::exception& e) {
13380       {
13381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13382       };
13383     } catch (Dali::DaliException e) {
13384       {
13385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13386       };
13387     } catch (...) {
13388       {
13389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13390       };
13391     }
13392   }
13393
13394 }
13395
13396
13397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13398   void * jresult ;
13399   Dali::Matrix3 *result = 0 ;
13400
13401   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13402   jresult = (void *)result;
13403   return jresult;
13404 }
13405
13406
13407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13408   void * jresult ;
13409   Dali::Matrix3 *result = 0 ;
13410
13411   {
13412     try {
13413       result = (Dali::Matrix3 *)new Dali::Matrix3();
13414     } catch (std::out_of_range& e) {
13415       {
13416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13417       };
13418     } catch (std::exception& e) {
13419       {
13420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13421       };
13422     } catch (Dali::DaliException e) {
13423       {
13424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13425       };
13426     } catch (...) {
13427       {
13428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13429       };
13430     }
13431   }
13432
13433   jresult = (void *)result;
13434   return jresult;
13435 }
13436
13437
13438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13439   void * jresult ;
13440   Dali::Matrix3 *arg1 = 0 ;
13441   Dali::Matrix3 *result = 0 ;
13442
13443   arg1 = (Dali::Matrix3 *)jarg1;
13444   if (!arg1) {
13445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13446     return 0;
13447   }
13448   {
13449     try {
13450       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13451     } catch (std::out_of_range& e) {
13452       {
13453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13454       };
13455     } catch (std::exception& e) {
13456       {
13457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13458       };
13459     } catch (Dali::DaliException e) {
13460       {
13461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13462       };
13463     } catch (...) {
13464       {
13465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13466       };
13467     }
13468   }
13469
13470   jresult = (void *)result;
13471   return jresult;
13472 }
13473
13474
13475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13476   void * jresult ;
13477   Dali::Matrix *arg1 = 0 ;
13478   Dali::Matrix3 *result = 0 ;
13479
13480   arg1 = (Dali::Matrix *)jarg1;
13481   if (!arg1) {
13482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13483     return 0;
13484   }
13485   {
13486     try {
13487       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13488     } catch (std::out_of_range& e) {
13489       {
13490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13491       };
13492     } catch (std::exception& e) {
13493       {
13494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13495       };
13496     } catch (Dali::DaliException e) {
13497       {
13498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13499       };
13500     } catch (...) {
13501       {
13502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13503       };
13504     }
13505   }
13506
13507   jresult = (void *)result;
13508   return jresult;
13509 }
13510
13511
13512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
13513   void * jresult ;
13514   float arg1 ;
13515   float arg2 ;
13516   float arg3 ;
13517   float arg4 ;
13518   float arg5 ;
13519   float arg6 ;
13520   float arg7 ;
13521   float arg8 ;
13522   float arg9 ;
13523   Dali::Matrix3 *result = 0 ;
13524
13525   arg1 = (float)jarg1;
13526   arg2 = (float)jarg2;
13527   arg3 = (float)jarg3;
13528   arg4 = (float)jarg4;
13529   arg5 = (float)jarg5;
13530   arg6 = (float)jarg6;
13531   arg7 = (float)jarg7;
13532   arg8 = (float)jarg8;
13533   arg9 = (float)jarg9;
13534   {
13535     try {
13536       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13537     } catch (std::out_of_range& e) {
13538       {
13539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13540       };
13541     } catch (std::exception& e) {
13542       {
13543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13544       };
13545     } catch (Dali::DaliException e) {
13546       {
13547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13548       };
13549     } catch (...) {
13550       {
13551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13552       };
13553     }
13554   }
13555
13556   jresult = (void *)result;
13557   return jresult;
13558 }
13559
13560
13561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13562   void * jresult ;
13563   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13564   Dali::Matrix3 *arg2 = 0 ;
13565   Dali::Matrix3 *result = 0 ;
13566
13567   arg1 = (Dali::Matrix3 *)jarg1;
13568   arg2 = (Dali::Matrix3 *)jarg2;
13569   if (!arg2) {
13570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13571     return 0;
13572   }
13573   {
13574     try {
13575       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13576     } catch (std::out_of_range& e) {
13577       {
13578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13579       };
13580     } catch (std::exception& e) {
13581       {
13582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13583       };
13584     } catch (Dali::DaliException e) {
13585       {
13586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13587       };
13588     } catch (...) {
13589       {
13590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13591       };
13592     }
13593   }
13594
13595   jresult = (void *)result;
13596   return jresult;
13597 }
13598
13599
13600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13601   void * jresult ;
13602   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13603   Dali::Matrix *arg2 = 0 ;
13604   Dali::Matrix3 *result = 0 ;
13605
13606   arg1 = (Dali::Matrix3 *)jarg1;
13607   arg2 = (Dali::Matrix *)jarg2;
13608   if (!arg2) {
13609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13610     return 0;
13611   }
13612   {
13613     try {
13614       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13615     } catch (std::out_of_range& e) {
13616       {
13617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13618       };
13619     } catch (std::exception& e) {
13620       {
13621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13622       };
13623     } catch (Dali::DaliException e) {
13624       {
13625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13626       };
13627     } catch (...) {
13628       {
13629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13630       };
13631     }
13632   }
13633
13634   jresult = (void *)result;
13635   return jresult;
13636 }
13637
13638
13639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13640   unsigned int jresult ;
13641   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13642   Dali::Matrix3 *arg2 = 0 ;
13643   bool result;
13644
13645   arg1 = (Dali::Matrix3 *)jarg1;
13646   arg2 = (Dali::Matrix3 *)jarg2;
13647   if (!arg2) {
13648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13649     return 0;
13650   }
13651   {
13652     try {
13653       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13654     } catch (std::out_of_range& e) {
13655       {
13656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13657       };
13658     } catch (std::exception& e) {
13659       {
13660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13661       };
13662     } catch (Dali::DaliException e) {
13663       {
13664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13665       };
13666     } catch (...) {
13667       {
13668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13669       };
13670     }
13671   }
13672
13673   jresult = result;
13674   return jresult;
13675 }
13676
13677
13678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13679   unsigned int jresult ;
13680   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13681   Dali::Matrix3 *arg2 = 0 ;
13682   bool result;
13683
13684   arg1 = (Dali::Matrix3 *)jarg1;
13685   arg2 = (Dali::Matrix3 *)jarg2;
13686   if (!arg2) {
13687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13688     return 0;
13689   }
13690   {
13691     try {
13692       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13693     } catch (std::out_of_range& e) {
13694       {
13695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13696       };
13697     } catch (std::exception& e) {
13698       {
13699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13700       };
13701     } catch (Dali::DaliException e) {
13702       {
13703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13704       };
13705     } catch (...) {
13706       {
13707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13708       };
13709     }
13710   }
13711
13712   jresult = result;
13713   return jresult;
13714 }
13715
13716
13717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13718   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13719
13720   arg1 = (Dali::Matrix3 *)jarg1;
13721   {
13722     try {
13723       delete arg1;
13724     } catch (std::out_of_range& e) {
13725       {
13726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13727       };
13728     } catch (std::exception& e) {
13729       {
13730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13731       };
13732     } catch (Dali::DaliException e) {
13733       {
13734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13735       };
13736     } catch (...) {
13737       {
13738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13739       };
13740     }
13741   }
13742
13743 }
13744
13745
13746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13747   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13748
13749   arg1 = (Dali::Matrix3 *)jarg1;
13750   {
13751     try {
13752       (arg1)->SetIdentity();
13753     } catch (std::out_of_range& e) {
13754       {
13755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13756       };
13757     } catch (std::exception& e) {
13758       {
13759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13760       };
13761     } catch (Dali::DaliException e) {
13762       {
13763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13764       };
13765     } catch (...) {
13766       {
13767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13768       };
13769     }
13770   }
13771
13772 }
13773
13774
13775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13776   void * jresult ;
13777   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13778   float *result = 0 ;
13779
13780   arg1 = (Dali::Matrix3 *)jarg1;
13781   {
13782     try {
13783       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13784     } catch (std::out_of_range& e) {
13785       {
13786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13787       };
13788     } catch (std::exception& e) {
13789       {
13790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13791       };
13792     } catch (Dali::DaliException e) {
13793       {
13794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13795       };
13796     } catch (...) {
13797       {
13798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13799       };
13800     }
13801   }
13802
13803   jresult = (void *)result;
13804   return jresult;
13805 }
13806
13807
13808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13809   unsigned int jresult ;
13810   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13811   bool result;
13812
13813   arg1 = (Dali::Matrix3 *)jarg1;
13814   {
13815     try {
13816       result = (bool)(arg1)->Invert();
13817     } catch (std::out_of_range& e) {
13818       {
13819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13820       };
13821     } catch (std::exception& e) {
13822       {
13823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13824       };
13825     } catch (Dali::DaliException e) {
13826       {
13827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13828       };
13829     } catch (...) {
13830       {
13831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13832       };
13833     }
13834   }
13835
13836   jresult = result;
13837   return jresult;
13838 }
13839
13840
13841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13842   unsigned int jresult ;
13843   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13844   bool result;
13845
13846   arg1 = (Dali::Matrix3 *)jarg1;
13847   {
13848     try {
13849       result = (bool)(arg1)->Transpose();
13850     } catch (std::out_of_range& e) {
13851       {
13852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13853       };
13854     } catch (std::exception& e) {
13855       {
13856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13857       };
13858     } catch (Dali::DaliException e) {
13859       {
13860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13861       };
13862     } catch (...) {
13863       {
13864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13865       };
13866     }
13867   }
13868
13869   jresult = result;
13870   return jresult;
13871 }
13872
13873
13874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13875   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13876   float arg2 ;
13877
13878   arg1 = (Dali::Matrix3 *)jarg1;
13879   arg2 = (float)jarg2;
13880   {
13881     try {
13882       (arg1)->Scale(arg2);
13883     } catch (std::out_of_range& e) {
13884       {
13885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13886       };
13887     } catch (std::exception& e) {
13888       {
13889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13890       };
13891     } catch (Dali::DaliException e) {
13892       {
13893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13894       };
13895     } catch (...) {
13896       {
13897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13898       };
13899     }
13900   }
13901
13902 }
13903
13904
13905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13906   float jresult ;
13907   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13908   float result;
13909
13910   arg1 = (Dali::Matrix3 *)jarg1;
13911   {
13912     try {
13913       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13914     } catch (std::out_of_range& e) {
13915       {
13916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13917       };
13918     } catch (std::exception& e) {
13919       {
13920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13921       };
13922     } catch (Dali::DaliException e) {
13923       {
13924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13925       };
13926     } catch (...) {
13927       {
13928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13929       };
13930     }
13931   }
13932
13933   jresult = result;
13934   return jresult;
13935 }
13936
13937
13938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13939   unsigned int jresult ;
13940   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13941   bool result;
13942
13943   arg1 = (Dali::Matrix3 *)jarg1;
13944   {
13945     try {
13946       result = (bool)(arg1)->ScaledInverseTranspose();
13947     } catch (std::out_of_range& e) {
13948       {
13949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13950       };
13951     } catch (std::exception& e) {
13952       {
13953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13954       };
13955     } catch (Dali::DaliException e) {
13956       {
13957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13958       };
13959     } catch (...) {
13960       {
13961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13962       };
13963     }
13964   }
13965
13966   jresult = result;
13967   return jresult;
13968 }
13969
13970
13971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13972   Dali::Matrix3 *arg1 = 0 ;
13973   Dali::Matrix3 *arg2 = 0 ;
13974   Dali::Matrix3 *arg3 = 0 ;
13975
13976   arg1 = (Dali::Matrix3 *)jarg1;
13977   if (!arg1) {
13978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13979     return ;
13980   }
13981   arg2 = (Dali::Matrix3 *)jarg2;
13982   if (!arg2) {
13983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13984     return ;
13985   }
13986   arg3 = (Dali::Matrix3 *)jarg3;
13987   if (!arg3) {
13988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13989     return ;
13990   }
13991   {
13992     try {
13993       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13994     } catch (std::out_of_range& e) {
13995       {
13996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13997       };
13998     } catch (std::exception& e) {
13999       {
14000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14001       };
14002     } catch (Dali::DaliException e) {
14003       {
14004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14005       };
14006     } catch (...) {
14007       {
14008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14009       };
14010     }
14011   }
14012
14013 }
14014
14015
14016 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14017   float jresult ;
14018   float arg1 ;
14019   float arg2 ;
14020   float result;
14021
14022   arg1 = (float)jarg1;
14023   arg2 = (float)jarg2;
14024   {
14025     try {
14026       result = (float)Dali::Random::Range(arg1,arg2);
14027     } catch (std::out_of_range& e) {
14028       {
14029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14030       };
14031     } catch (std::exception& e) {
14032       {
14033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14034       };
14035     } catch (Dali::DaliException e) {
14036       {
14037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14038       };
14039     } catch (...) {
14040       {
14041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14042       };
14043     }
14044   }
14045
14046   jresult = result;
14047   return jresult;
14048 }
14049
14050
14051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14052   void * jresult ;
14053   Dali::Vector4 result;
14054
14055   {
14056     try {
14057       result = Dali::Random::Axis();
14058     } catch (std::out_of_range& e) {
14059       {
14060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14061       };
14062     } catch (std::exception& e) {
14063       {
14064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14065       };
14066     } catch (Dali::DaliException e) {
14067       {
14068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14069       };
14070     } catch (...) {
14071       {
14072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14073       };
14074     }
14075   }
14076
14077   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14078   return jresult;
14079 }
14080
14081
14082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14083   void * jresult ;
14084   Dali::AngleAxis *result = 0 ;
14085
14086   {
14087     try {
14088       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14089     } catch (std::out_of_range& e) {
14090       {
14091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14092       };
14093     } catch (std::exception& e) {
14094       {
14095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14096       };
14097     } catch (Dali::DaliException e) {
14098       {
14099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14100       };
14101     } catch (...) {
14102       {
14103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14104       };
14105     }
14106   }
14107
14108   jresult = (void *)result;
14109   return jresult;
14110 }
14111
14112
14113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14114   void * jresult ;
14115   Dali::Radian arg1 ;
14116   Dali::Vector3 *arg2 = 0 ;
14117   Dali::Radian *argp1 ;
14118   Dali::AngleAxis *result = 0 ;
14119
14120   argp1 = (Dali::Radian *)jarg1;
14121   if (!argp1) {
14122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14123     return 0;
14124   }
14125   arg1 = *argp1;
14126   arg2 = (Dali::Vector3 *)jarg2;
14127   if (!arg2) {
14128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14129     return 0;
14130   }
14131   {
14132     try {
14133       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14134     } catch (std::out_of_range& e) {
14135       {
14136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14137       };
14138     } catch (std::exception& e) {
14139       {
14140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14141       };
14142     } catch (Dali::DaliException e) {
14143       {
14144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14145       };
14146     } catch (...) {
14147       {
14148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14149       };
14150     }
14151   }
14152
14153   jresult = (void *)result;
14154   return jresult;
14155 }
14156
14157
14158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14159   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14160   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14161
14162   arg1 = (Dali::AngleAxis *)jarg1;
14163   arg2 = (Dali::Radian *)jarg2;
14164   if (arg1) (arg1)->angle = *arg2;
14165 }
14166
14167
14168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14169   void * jresult ;
14170   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14171   Dali::Radian *result = 0 ;
14172
14173   arg1 = (Dali::AngleAxis *)jarg1;
14174   result = (Dali::Radian *)& ((arg1)->angle);
14175   jresult = (void *)result;
14176   return jresult;
14177 }
14178
14179
14180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14181   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14182   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14183
14184   arg1 = (Dali::AngleAxis *)jarg1;
14185   arg2 = (Dali::Vector3 *)jarg2;
14186   if (arg1) (arg1)->axis = *arg2;
14187 }
14188
14189
14190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14191   void * jresult ;
14192   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14193   Dali::Vector3 *result = 0 ;
14194
14195   arg1 = (Dali::AngleAxis *)jarg1;
14196   result = (Dali::Vector3 *)& ((arg1)->axis);
14197   jresult = (void *)result;
14198   return jresult;
14199 }
14200
14201
14202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14203   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14204
14205   arg1 = (Dali::AngleAxis *)jarg1;
14206   {
14207     try {
14208       delete arg1;
14209     } catch (std::out_of_range& e) {
14210       {
14211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14212       };
14213     } catch (std::exception& e) {
14214       {
14215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14216       };
14217     } catch (Dali::DaliException e) {
14218       {
14219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14220       };
14221     } catch (...) {
14222       {
14223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14224       };
14225     }
14226   }
14227
14228 }
14229
14230
14231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14232   unsigned int jresult ;
14233   Dali::AngleAxis *arg1 = 0 ;
14234   Dali::AngleAxis *arg2 = 0 ;
14235   bool result;
14236
14237   arg1 = (Dali::AngleAxis *)jarg1;
14238   if (!arg1) {
14239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14240     return 0;
14241   }
14242   arg2 = (Dali::AngleAxis *)jarg2;
14243   if (!arg2) {
14244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14245     return 0;
14246   }
14247   {
14248     try {
14249       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14250     } catch (std::out_of_range& e) {
14251       {
14252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14253       };
14254     } catch (std::exception& e) {
14255       {
14256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14257       };
14258     } catch (Dali::DaliException e) {
14259       {
14260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14261       };
14262     } catch (...) {
14263       {
14264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14265       };
14266     }
14267   }
14268
14269   jresult = result;
14270   return jresult;
14271 }
14272
14273
14274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14275   unsigned int jresult ;
14276   unsigned int arg1 ;
14277   unsigned int result;
14278
14279   arg1 = (unsigned int)jarg1;
14280   {
14281     try {
14282       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14283     } catch (std::out_of_range& e) {
14284       {
14285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14286       };
14287     } catch (std::exception& e) {
14288       {
14289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14290       };
14291     } catch (Dali::DaliException e) {
14292       {
14293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14294       };
14295     } catch (...) {
14296       {
14297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14298       };
14299     }
14300   }
14301
14302   jresult = result;
14303   return jresult;
14304 }
14305
14306
14307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14308   unsigned int jresult ;
14309   unsigned int arg1 ;
14310   bool result;
14311
14312   arg1 = (unsigned int)jarg1;
14313   {
14314     try {
14315       result = (bool)Dali::IsPowerOfTwo(arg1);
14316     } catch (std::out_of_range& e) {
14317       {
14318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14319       };
14320     } catch (std::exception& e) {
14321       {
14322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14323       };
14324     } catch (Dali::DaliException e) {
14325       {
14326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14327       };
14328     } catch (...) {
14329       {
14330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14331       };
14332     }
14333   }
14334
14335   jresult = result;
14336   return jresult;
14337 }
14338
14339
14340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14341   float jresult ;
14342   float arg1 ;
14343   float arg2 ;
14344   float result;
14345
14346   arg1 = (float)jarg1;
14347   arg2 = (float)jarg2;
14348   {
14349     try {
14350       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14351     } catch (std::out_of_range& e) {
14352       {
14353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14354       };
14355     } catch (std::exception& e) {
14356       {
14357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14358       };
14359     } catch (Dali::DaliException e) {
14360       {
14361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14362       };
14363     } catch (...) {
14364       {
14365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14366       };
14367     }
14368   }
14369
14370   jresult = result;
14371   return jresult;
14372 }
14373
14374
14375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14376   unsigned int jresult ;
14377   float arg1 ;
14378   bool result;
14379
14380   arg1 = (float)jarg1;
14381   {
14382     try {
14383       result = (bool)Dali::EqualsZero(arg1);
14384     } catch (std::out_of_range& e) {
14385       {
14386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14387       };
14388     } catch (std::exception& e) {
14389       {
14390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14391       };
14392     } catch (Dali::DaliException e) {
14393       {
14394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14395       };
14396     } catch (...) {
14397       {
14398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14399       };
14400     }
14401   }
14402
14403   jresult = result;
14404   return jresult;
14405 }
14406
14407
14408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14409   unsigned int jresult ;
14410   float arg1 ;
14411   float arg2 ;
14412   bool result;
14413
14414   arg1 = (float)jarg1;
14415   arg2 = (float)jarg2;
14416   {
14417     try {
14418       result = (bool)Dali::Equals(arg1,arg2);
14419     } catch (std::out_of_range& e) {
14420       {
14421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14422       };
14423     } catch (std::exception& e) {
14424       {
14425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14426       };
14427     } catch (Dali::DaliException e) {
14428       {
14429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14430       };
14431     } catch (...) {
14432       {
14433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14434       };
14435     }
14436   }
14437
14438   jresult = result;
14439   return jresult;
14440 }
14441
14442
14443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14444   unsigned int jresult ;
14445   float arg1 ;
14446   float arg2 ;
14447   float arg3 ;
14448   bool result;
14449
14450   arg1 = (float)jarg1;
14451   arg2 = (float)jarg2;
14452   arg3 = (float)jarg3;
14453   {
14454     try {
14455       result = (bool)Dali::Equals(arg1,arg2,arg3);
14456     } catch (std::out_of_range& e) {
14457       {
14458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14459       };
14460     } catch (std::exception& e) {
14461       {
14462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14463       };
14464     } catch (Dali::DaliException e) {
14465       {
14466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14467       };
14468     } catch (...) {
14469       {
14470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14471       };
14472     }
14473   }
14474
14475   jresult = result;
14476   return jresult;
14477 }
14478
14479
14480 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14481   float jresult ;
14482   float arg1 ;
14483   int arg2 ;
14484   float result;
14485
14486   arg1 = (float)jarg1;
14487   arg2 = (int)jarg2;
14488   {
14489     try {
14490       result = (float)Dali::Round(arg1,arg2);
14491     } catch (std::out_of_range& e) {
14492       {
14493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14494       };
14495     } catch (std::exception& e) {
14496       {
14497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14498       };
14499     } catch (Dali::DaliException e) {
14500       {
14501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14502       };
14503     } catch (...) {
14504       {
14505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14506       };
14507     }
14508   }
14509
14510   jresult = result;
14511   return jresult;
14512 }
14513
14514
14515 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14516   float jresult ;
14517   float arg1 ;
14518   float arg2 ;
14519   float arg3 ;
14520   float result;
14521
14522   arg1 = (float)jarg1;
14523   arg2 = (float)jarg2;
14524   arg3 = (float)jarg3;
14525   {
14526     try {
14527       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14528     } catch (std::out_of_range& e) {
14529       {
14530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14531       };
14532     } catch (std::exception& e) {
14533       {
14534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14535       };
14536     } catch (Dali::DaliException e) {
14537       {
14538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14539       };
14540     } catch (...) {
14541       {
14542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14543       };
14544     }
14545   }
14546
14547   jresult = result;
14548   return jresult;
14549 }
14550
14551
14552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14553   float jresult ;
14554   float arg1 ;
14555   float arg2 ;
14556   float arg3 ;
14557   float arg4 ;
14558   float result;
14559
14560   arg1 = (float)jarg1;
14561   arg2 = (float)jarg2;
14562   arg3 = (float)jarg3;
14563   arg4 = (float)jarg4;
14564   {
14565     try {
14566       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14567     } catch (std::out_of_range& e) {
14568       {
14569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14570       };
14571     } catch (std::exception& e) {
14572       {
14573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14574       };
14575     } catch (Dali::DaliException e) {
14576       {
14577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14578       };
14579     } catch (...) {
14580       {
14581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14582       };
14583     }
14584   }
14585
14586   jresult = result;
14587   return jresult;
14588 }
14589
14590
14591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14592   int jresult ;
14593   int result;
14594
14595   result = (int)(int)Dali::Property::INVALID_INDEX;
14596   jresult = result;
14597   return jresult;
14598 }
14599
14600
14601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14602   int jresult ;
14603   int result;
14604
14605   result = (int)(int)Dali::Property::INVALID_KEY;
14606   jresult = result;
14607   return jresult;
14608 }
14609
14610
14611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14612   int jresult ;
14613   int result;
14614
14615   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14616   jresult = result;
14617   return jresult;
14618 }
14619
14620
14621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14622   void * jresult ;
14623   Dali::Handle *arg1 = 0 ;
14624   Dali::Property::Index arg2 ;
14625   Dali::Property *result = 0 ;
14626
14627   arg1 = (Dali::Handle *)jarg1;
14628   if (!arg1) {
14629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14630     return 0;
14631   }
14632   arg2 = (Dali::Property::Index)jarg2;
14633   {
14634     try {
14635       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14636     } catch (std::out_of_range& e) {
14637       {
14638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14639       };
14640     } catch (std::exception& e) {
14641       {
14642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14643       };
14644     } catch (Dali::DaliException e) {
14645       {
14646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14647       };
14648     } catch (...) {
14649       {
14650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14651       };
14652     }
14653   }
14654
14655   jresult = (void *)result;
14656   return jresult;
14657 }
14658
14659
14660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14661   void * jresult ;
14662   Dali::Handle *arg1 = 0 ;
14663   Dali::Property::Index arg2 ;
14664   int arg3 ;
14665   Dali::Property *result = 0 ;
14666
14667   arg1 = (Dali::Handle *)jarg1;
14668   if (!arg1) {
14669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14670     return 0;
14671   }
14672   arg2 = (Dali::Property::Index)jarg2;
14673   arg3 = (int)jarg3;
14674   {
14675     try {
14676       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14677     } catch (std::out_of_range& e) {
14678       {
14679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14680       };
14681     } catch (std::exception& e) {
14682       {
14683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14684       };
14685     } catch (Dali::DaliException e) {
14686       {
14687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14688       };
14689     } catch (...) {
14690       {
14691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14692       };
14693     }
14694   }
14695
14696   jresult = (void *)result;
14697   return jresult;
14698 }
14699
14700
14701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14702   void * jresult ;
14703   Dali::Handle *arg1 = 0 ;
14704   std::string *arg2 = 0 ;
14705   Dali::Property *result = 0 ;
14706
14707   arg1 = (Dali::Handle *)jarg1;
14708   if (!arg1) {
14709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14710     return 0;
14711   }
14712   if (!jarg2) {
14713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14714     return 0;
14715   }
14716   std::string arg2_str(jarg2);
14717   arg2 = &arg2_str;
14718   {
14719     try {
14720       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14721     } catch (std::out_of_range& e) {
14722       {
14723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14724       };
14725     } catch (std::exception& e) {
14726       {
14727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14728       };
14729     } catch (Dali::DaliException e) {
14730       {
14731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14732       };
14733     } catch (...) {
14734       {
14735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14736       };
14737     }
14738   }
14739
14740   jresult = (void *)result;
14741
14742   //argout typemap for const std::string&
14743
14744   return jresult;
14745 }
14746
14747
14748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14749   void * jresult ;
14750   Dali::Handle *arg1 = 0 ;
14751   std::string *arg2 = 0 ;
14752   int arg3 ;
14753   Dali::Property *result = 0 ;
14754
14755   arg1 = (Dali::Handle *)jarg1;
14756   if (!arg1) {
14757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14758     return 0;
14759   }
14760   if (!jarg2) {
14761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14762     return 0;
14763   }
14764   std::string arg2_str(jarg2);
14765   arg2 = &arg2_str;
14766   arg3 = (int)jarg3;
14767   {
14768     try {
14769       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14770     } catch (std::out_of_range& e) {
14771       {
14772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14773       };
14774     } catch (std::exception& e) {
14775       {
14776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14777       };
14778     } catch (Dali::DaliException e) {
14779       {
14780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14781       };
14782     } catch (...) {
14783       {
14784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14785       };
14786     }
14787   }
14788
14789   jresult = (void *)result;
14790
14791   //argout typemap for const std::string&
14792
14793   return jresult;
14794 }
14795
14796
14797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14798   Dali::Property *arg1 = (Dali::Property *) 0 ;
14799
14800   arg1 = (Dali::Property *)jarg1;
14801   {
14802     try {
14803       delete arg1;
14804     } catch (std::out_of_range& e) {
14805       {
14806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14807       };
14808     } catch (std::exception& e) {
14809       {
14810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14811       };
14812     } catch (Dali::DaliException e) {
14813       {
14814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14815       };
14816     } catch (...) {
14817       {
14818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14819       };
14820     }
14821   }
14822
14823 }
14824
14825
14826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14827   Dali::Property *arg1 = (Dali::Property *) 0 ;
14828   Dali::Handle *arg2 = 0 ;
14829
14830   arg1 = (Dali::Property *)jarg1;
14831   arg2 = (Dali::Handle *)jarg2;
14832   if (!arg2) {
14833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14834     return ;
14835   }
14836   if (arg1) (arg1)->object = *arg2;
14837 }
14838
14839
14840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14841   void * jresult ;
14842   Dali::Property *arg1 = (Dali::Property *) 0 ;
14843   Dali::Handle *result = 0 ;
14844
14845   arg1 = (Dali::Property *)jarg1;
14846   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14847   jresult = (void *)result;
14848   return jresult;
14849 }
14850
14851
14852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14853   Dali::Property *arg1 = (Dali::Property *) 0 ;
14854   Dali::Property::Index arg2 ;
14855
14856   arg1 = (Dali::Property *)jarg1;
14857   arg2 = (Dali::Property::Index)jarg2;
14858   if (arg1) (arg1)->propertyIndex = arg2;
14859 }
14860
14861
14862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14863   int jresult ;
14864   Dali::Property *arg1 = (Dali::Property *) 0 ;
14865   Dali::Property::Index result;
14866
14867   arg1 = (Dali::Property *)jarg1;
14868   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14869   jresult = result;
14870   return jresult;
14871 }
14872
14873
14874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14875   Dali::Property *arg1 = (Dali::Property *) 0 ;
14876   int arg2 ;
14877
14878   arg1 = (Dali::Property *)jarg1;
14879   arg2 = (int)jarg2;
14880   if (arg1) (arg1)->componentIndex = arg2;
14881 }
14882
14883
14884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14885   int jresult ;
14886   Dali::Property *arg1 = (Dali::Property *) 0 ;
14887   int result;
14888
14889   arg1 = (Dali::Property *)jarg1;
14890   result = (int) ((arg1)->componentIndex);
14891   jresult = result;
14892   return jresult;
14893 }
14894
14895
14896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14897   void * jresult ;
14898   Dali::Property::Array *result = 0 ;
14899
14900   {
14901     try {
14902       result = (Dali::Property::Array *)new Dali::Property::Array();
14903     } catch (std::out_of_range& e) {
14904       {
14905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14906       };
14907     } catch (std::exception& e) {
14908       {
14909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14910       };
14911     } catch (Dali::DaliException e) {
14912       {
14913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14914       };
14915     } catch (...) {
14916       {
14917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14918       };
14919     }
14920   }
14921
14922   jresult = (void *)result;
14923   return jresult;
14924 }
14925
14926
14927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14928   void * jresult ;
14929   Dali::Property::Array *arg1 = 0 ;
14930   Dali::Property::Array *result = 0 ;
14931
14932   arg1 = (Dali::Property::Array *)jarg1;
14933   if (!arg1) {
14934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14935     return 0;
14936   }
14937   {
14938     try {
14939       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14940     } catch (std::out_of_range& e) {
14941       {
14942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14943       };
14944     } catch (std::exception& e) {
14945       {
14946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14947       };
14948     } catch (Dali::DaliException e) {
14949       {
14950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14951       };
14952     } catch (...) {
14953       {
14954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14955       };
14956     }
14957   }
14958
14959   jresult = (void *)result;
14960   return jresult;
14961 }
14962
14963
14964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14965   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14966
14967   arg1 = (Dali::Property::Array *)jarg1;
14968   {
14969     try {
14970       delete arg1;
14971     } catch (std::out_of_range& e) {
14972       {
14973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14974       };
14975     } catch (std::exception& e) {
14976       {
14977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14978       };
14979     } catch (Dali::DaliException e) {
14980       {
14981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14982       };
14983     } catch (...) {
14984       {
14985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14986       };
14987     }
14988   }
14989
14990 }
14991
14992
14993 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14994   unsigned long jresult ;
14995   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14996   Dali::Property::Array::SizeType result;
14997
14998   arg1 = (Dali::Property::Array *)jarg1;
14999   {
15000     try {
15001       result = ((Dali::Property::Array const *)arg1)->Size();
15002     } catch (std::out_of_range& e) {
15003       {
15004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15005       };
15006     } catch (std::exception& e) {
15007       {
15008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15009       };
15010     } catch (Dali::DaliException e) {
15011       {
15012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15013       };
15014     } catch (...) {
15015       {
15016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15017       };
15018     }
15019   }
15020
15021   jresult = (unsigned long)result;
15022   return jresult;
15023 }
15024
15025
15026 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15027   unsigned long jresult ;
15028   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15029   Dali::Property::Array::SizeType result;
15030
15031   arg1 = (Dali::Property::Array *)jarg1;
15032   {
15033     try {
15034       result = ((Dali::Property::Array const *)arg1)->Count();
15035     } catch (std::out_of_range& e) {
15036       {
15037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15038       };
15039     } catch (std::exception& e) {
15040       {
15041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15042       };
15043     } catch (Dali::DaliException e) {
15044       {
15045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15046       };
15047     } catch (...) {
15048       {
15049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15050       };
15051     }
15052   }
15053
15054   jresult = (unsigned long)result;
15055   return jresult;
15056 }
15057
15058
15059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15060   unsigned int jresult ;
15061   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15062   bool result;
15063
15064   arg1 = (Dali::Property::Array *)jarg1;
15065   {
15066     try {
15067       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15068     } catch (std::out_of_range& e) {
15069       {
15070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15071       };
15072     } catch (std::exception& e) {
15073       {
15074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15075       };
15076     } catch (Dali::DaliException e) {
15077       {
15078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15079       };
15080     } catch (...) {
15081       {
15082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15083       };
15084     }
15085   }
15086
15087   jresult = result;
15088   return jresult;
15089 }
15090
15091
15092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15093   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15094
15095   arg1 = (Dali::Property::Array *)jarg1;
15096   {
15097     try {
15098       (arg1)->Clear();
15099     } catch (std::out_of_range& e) {
15100       {
15101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15102       };
15103     } catch (std::exception& e) {
15104       {
15105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15106       };
15107     } catch (Dali::DaliException e) {
15108       {
15109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15110       };
15111     } catch (...) {
15112       {
15113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15114       };
15115     }
15116   }
15117
15118 }
15119
15120
15121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15122   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15123   Dali::Property::Array::SizeType arg2 ;
15124
15125   arg1 = (Dali::Property::Array *)jarg1;
15126   arg2 = (Dali::Property::Array::SizeType)jarg2;
15127   {
15128     try {
15129       (arg1)->Reserve(arg2);
15130     } catch (std::out_of_range& e) {
15131       {
15132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15133       };
15134     } catch (std::exception& e) {
15135       {
15136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15137       };
15138     } catch (Dali::DaliException e) {
15139       {
15140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15141       };
15142     } catch (...) {
15143       {
15144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15145       };
15146     }
15147   }
15148
15149 }
15150
15151
15152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15153   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15154   Dali::Property::Array::SizeType arg2 ;
15155
15156   arg1 = (Dali::Property::Array *)jarg1;
15157   arg2 = (Dali::Property::Array::SizeType)jarg2;
15158   {
15159     try {
15160       (arg1)->Resize(arg2);
15161     } catch (std::out_of_range& e) {
15162       {
15163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15164       };
15165     } catch (std::exception& e) {
15166       {
15167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15168       };
15169     } catch (Dali::DaliException e) {
15170       {
15171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15172       };
15173     } catch (...) {
15174       {
15175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15176       };
15177     }
15178   }
15179
15180 }
15181
15182
15183 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15184   unsigned long jresult ;
15185   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15186   Dali::Property::Array::SizeType result;
15187
15188   arg1 = (Dali::Property::Array *)jarg1;
15189   {
15190     try {
15191       result = (arg1)->Capacity();
15192     } catch (std::out_of_range& e) {
15193       {
15194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15195       };
15196     } catch (std::exception& e) {
15197       {
15198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15199       };
15200     } catch (Dali::DaliException e) {
15201       {
15202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15203       };
15204     } catch (...) {
15205       {
15206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15207       };
15208     }
15209   }
15210
15211   jresult = (unsigned long)result;
15212   return jresult;
15213 }
15214
15215
15216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15217   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15218   Dali::Property::Value *arg2 = 0 ;
15219
15220   arg1 = (Dali::Property::Array *)jarg1;
15221   arg2 = (Dali::Property::Value *)jarg2;
15222   if (!arg2) {
15223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15224     return ;
15225   }
15226   {
15227     try {
15228       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15229     } catch (std::out_of_range& e) {
15230       {
15231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15232       };
15233     } catch (std::exception& e) {
15234       {
15235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15236       };
15237     } catch (Dali::DaliException e) {
15238       {
15239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15240       };
15241     } catch (...) {
15242       {
15243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15244       };
15245     }
15246   }
15247
15248 }
15249
15250
15251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15252   void * jresult ;
15253   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15254   Dali::Property::Value *arg2 = 0 ;
15255   Dali::Property::Array *result = 0 ;
15256
15257   arg1 = (Dali::Property::Array *)jarg1;
15258   arg2 = (Dali::Property::Value *)jarg2;
15259   if (!arg2) {
15260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15261     return 0;
15262   }
15263   {
15264     try {
15265       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15266     } catch (std::out_of_range& e) {
15267       {
15268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15269       };
15270     } catch (std::exception& e) {
15271       {
15272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15273       };
15274     } catch (Dali::DaliException e) {
15275       {
15276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15277       };
15278     } catch (...) {
15279       {
15280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15281       };
15282     }
15283   }
15284
15285   jresult = (void *)result;
15286   return jresult;
15287 }
15288
15289
15290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15291   void * jresult ;
15292   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15293   Dali::Property::Array::SizeType arg2 ;
15294   Dali::Property::Value *result = 0 ;
15295
15296   arg1 = (Dali::Property::Array *)jarg1;
15297   arg2 = (Dali::Property::Array::SizeType)jarg2;
15298   {
15299     try {
15300       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15301     } catch (std::out_of_range& e) {
15302       {
15303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15304       };
15305     } catch (std::exception& e) {
15306       {
15307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15308       };
15309     } catch (Dali::DaliException e) {
15310       {
15311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15312       };
15313     } catch (...) {
15314       {
15315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15316       };
15317     }
15318   }
15319
15320   jresult = (void *)result;
15321   return jresult;
15322 }
15323
15324
15325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15326   void * jresult ;
15327   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15328   Dali::Property::Array::SizeType arg2 ;
15329   Dali::Property::Value *result = 0 ;
15330
15331   arg1 = (Dali::Property::Array *)jarg1;
15332   arg2 = (Dali::Property::Array::SizeType)jarg2;
15333   {
15334     try {
15335       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15336     } catch (std::out_of_range& e) {
15337       {
15338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15339       };
15340     } catch (std::exception& e) {
15341       {
15342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15343       };
15344     } catch (Dali::DaliException e) {
15345       {
15346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15347       };
15348     } catch (...) {
15349       {
15350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15351       };
15352     }
15353   }
15354
15355   jresult = (void *)result;
15356   return jresult;
15357 }
15358
15359
15360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15361   void * jresult ;
15362   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15363   Dali::Property::Array *arg2 = 0 ;
15364   Dali::Property::Array *result = 0 ;
15365
15366   arg1 = (Dali::Property::Array *)jarg1;
15367   arg2 = (Dali::Property::Array *)jarg2;
15368   if (!arg2) {
15369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15370     return 0;
15371   }
15372   {
15373     try {
15374       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15375     } catch (std::out_of_range& e) {
15376       {
15377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15378       };
15379     } catch (std::exception& e) {
15380       {
15381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15382       };
15383     } catch (Dali::DaliException e) {
15384       {
15385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15386       };
15387     } catch (...) {
15388       {
15389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15390       };
15391     }
15392   }
15393
15394   jresult = (void *)result;
15395   return jresult;
15396 }
15397
15398
15399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15400   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15401   enum Dali::Property::Key::Type arg2 ;
15402
15403   arg1 = (Dali::Property::Key *)jarg1;
15404   arg2 = (enum Dali::Property::Key::Type)jarg2;
15405   if (arg1) (arg1)->type = arg2;
15406 }
15407
15408
15409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15410   int jresult ;
15411   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15412   enum Dali::Property::Key::Type result;
15413
15414   arg1 = (Dali::Property::Key *)jarg1;
15415   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15416   jresult = (int)result;
15417   return jresult;
15418 }
15419
15420
15421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15422   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15423   Dali::Property::Index arg2 ;
15424
15425   arg1 = (Dali::Property::Key *)jarg1;
15426   arg2 = (Dali::Property::Index)jarg2;
15427   if (arg1) (arg1)->indexKey = arg2;
15428 }
15429
15430
15431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15432   int jresult ;
15433   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15434   Dali::Property::Index result;
15435
15436   arg1 = (Dali::Property::Key *)jarg1;
15437   result = (Dali::Property::Index) ((arg1)->indexKey);
15438   jresult = result;
15439   return jresult;
15440 }
15441
15442
15443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15444   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15445   std::string *arg2 = 0 ;
15446
15447   arg1 = (Dali::Property::Key *)jarg1;
15448   if (!jarg2) {
15449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15450     return ;
15451   }
15452   std::string arg2_str(jarg2);
15453   arg2 = &arg2_str;
15454   if (arg1) (arg1)->stringKey = *arg2;
15455
15456   //argout typemap for const std::string&
15457
15458 }
15459
15460
15461 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15462   char * jresult ;
15463   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15464   std::string *result = 0 ;
15465
15466   arg1 = (Dali::Property::Key *)jarg1;
15467   result = (std::string *) & ((arg1)->stringKey);
15468   jresult = SWIG_csharp_string_callback(result->c_str());
15469   return jresult;
15470 }
15471
15472
15473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15474   void * jresult ;
15475   std::string *arg1 = 0 ;
15476   Dali::Property::Key *result = 0 ;
15477
15478   if (!jarg1) {
15479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15480     return 0;
15481   }
15482   std::string arg1_str(jarg1);
15483   arg1 = &arg1_str;
15484   {
15485     try {
15486       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15487     } catch (std::out_of_range& e) {
15488       {
15489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15490       };
15491     } catch (std::exception& e) {
15492       {
15493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15494       };
15495     } catch (Dali::DaliException e) {
15496       {
15497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15498       };
15499     } catch (...) {
15500       {
15501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15502       };
15503     }
15504   }
15505
15506   jresult = (void *)result;
15507
15508   //argout typemap for const std::string&
15509
15510   return jresult;
15511 }
15512
15513
15514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15515   void * jresult ;
15516   Dali::Property::Index arg1 ;
15517   Dali::Property::Key *result = 0 ;
15518
15519   arg1 = (Dali::Property::Index)jarg1;
15520   {
15521     try {
15522       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15523     } catch (std::out_of_range& e) {
15524       {
15525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15526       };
15527     } catch (std::exception& e) {
15528       {
15529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15530       };
15531     } catch (Dali::DaliException e) {
15532       {
15533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15534       };
15535     } catch (...) {
15536       {
15537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15538       };
15539     }
15540   }
15541
15542   jresult = (void *)result;
15543   return jresult;
15544 }
15545
15546
15547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15548   unsigned int jresult ;
15549   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15550   std::string *arg2 = 0 ;
15551   bool result;
15552
15553   arg1 = (Dali::Property::Key *)jarg1;
15554   if (!jarg2) {
15555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15556     return 0;
15557   }
15558   std::string arg2_str(jarg2);
15559   arg2 = &arg2_str;
15560   {
15561     try {
15562       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15563     } catch (std::out_of_range& e) {
15564       {
15565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15566       };
15567     } catch (std::exception& e) {
15568       {
15569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15570       };
15571     } catch (Dali::DaliException e) {
15572       {
15573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15574       };
15575     } catch (...) {
15576       {
15577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15578       };
15579     }
15580   }
15581
15582   jresult = result;
15583
15584   //argout typemap for const std::string&
15585
15586   return jresult;
15587 }
15588
15589
15590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15591   unsigned int jresult ;
15592   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15593   Dali::Property::Index arg2 ;
15594   bool result;
15595
15596   arg1 = (Dali::Property::Key *)jarg1;
15597   arg2 = (Dali::Property::Index)jarg2;
15598   {
15599     try {
15600       result = (bool)(arg1)->operator ==(arg2);
15601     } catch (std::out_of_range& e) {
15602       {
15603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15604       };
15605     } catch (std::exception& e) {
15606       {
15607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15608       };
15609     } catch (Dali::DaliException e) {
15610       {
15611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15612       };
15613     } catch (...) {
15614       {
15615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15616       };
15617     }
15618   }
15619
15620   jresult = result;
15621   return jresult;
15622 }
15623
15624
15625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15626   unsigned int jresult ;
15627   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15628   Dali::Property::Key *arg2 = 0 ;
15629   bool result;
15630
15631   arg1 = (Dali::Property::Key *)jarg1;
15632   arg2 = (Dali::Property::Key *)jarg2;
15633   if (!arg2) {
15634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15635     return 0;
15636   }
15637   {
15638     try {
15639       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15640     } catch (std::out_of_range& e) {
15641       {
15642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15643       };
15644     } catch (std::exception& e) {
15645       {
15646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15647       };
15648     } catch (Dali::DaliException e) {
15649       {
15650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15651       };
15652     } catch (...) {
15653       {
15654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15655       };
15656     }
15657   }
15658
15659   jresult = result;
15660   return jresult;
15661 }
15662
15663
15664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15665   unsigned int jresult ;
15666   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15667   std::string *arg2 = 0 ;
15668   bool result;
15669
15670   arg1 = (Dali::Property::Key *)jarg1;
15671   if (!jarg2) {
15672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15673     return 0;
15674   }
15675   std::string arg2_str(jarg2);
15676   arg2 = &arg2_str;
15677   {
15678     try {
15679       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15680     } catch (std::out_of_range& e) {
15681       {
15682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15683       };
15684     } catch (std::exception& e) {
15685       {
15686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15687       };
15688     } catch (Dali::DaliException e) {
15689       {
15690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15691       };
15692     } catch (...) {
15693       {
15694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15695       };
15696     }
15697   }
15698
15699   jresult = result;
15700
15701   //argout typemap for const std::string&
15702
15703   return jresult;
15704 }
15705
15706
15707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15708   unsigned int jresult ;
15709   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15710   Dali::Property::Index arg2 ;
15711   bool result;
15712
15713   arg1 = (Dali::Property::Key *)jarg1;
15714   arg2 = (Dali::Property::Index)jarg2;
15715   {
15716     try {
15717       result = (bool)(arg1)->operator !=(arg2);
15718     } catch (std::out_of_range& e) {
15719       {
15720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15721       };
15722     } catch (std::exception& e) {
15723       {
15724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15725       };
15726     } catch (Dali::DaliException e) {
15727       {
15728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15729       };
15730     } catch (...) {
15731       {
15732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15733       };
15734     }
15735   }
15736
15737   jresult = result;
15738   return jresult;
15739 }
15740
15741
15742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15743   unsigned int jresult ;
15744   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15745   Dali::Property::Key *arg2 = 0 ;
15746   bool result;
15747
15748   arg1 = (Dali::Property::Key *)jarg1;
15749   arg2 = (Dali::Property::Key *)jarg2;
15750   if (!arg2) {
15751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15752     return 0;
15753   }
15754   {
15755     try {
15756       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15757     } catch (std::out_of_range& e) {
15758       {
15759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15760       };
15761     } catch (std::exception& e) {
15762       {
15763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15764       };
15765     } catch (Dali::DaliException e) {
15766       {
15767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15768       };
15769     } catch (...) {
15770       {
15771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15772       };
15773     }
15774   }
15775
15776   jresult = result;
15777   return jresult;
15778 }
15779
15780
15781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15782   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15783
15784   arg1 = (Dali::Property::Key *)jarg1;
15785   {
15786     try {
15787       delete arg1;
15788     } catch (std::out_of_range& e) {
15789       {
15790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15791       };
15792     } catch (std::exception& e) {
15793       {
15794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15795       };
15796     } catch (Dali::DaliException e) {
15797       {
15798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15799       };
15800     } catch (...) {
15801       {
15802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15803       };
15804     }
15805   }
15806
15807 }
15808
15809
15810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15811   void * jresult ;
15812   Dali::Property::Map *result = 0 ;
15813
15814   {
15815     try {
15816       result = (Dali::Property::Map *)new Dali::Property::Map();
15817     } catch (std::out_of_range& e) {
15818       {
15819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15820       };
15821     } catch (std::exception& e) {
15822       {
15823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15824       };
15825     } catch (Dali::DaliException e) {
15826       {
15827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15828       };
15829     } catch (...) {
15830       {
15831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15832       };
15833     }
15834   }
15835
15836   jresult = (void *)result;
15837   return jresult;
15838 }
15839
15840
15841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15842   void * jresult ;
15843   Dali::Property::Map *arg1 = 0 ;
15844   Dali::Property::Map *result = 0 ;
15845
15846   arg1 = (Dali::Property::Map *)jarg1;
15847   if (!arg1) {
15848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15849     return 0;
15850   }
15851   {
15852     try {
15853       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15854     } catch (std::out_of_range& e) {
15855       {
15856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15857       };
15858     } catch (std::exception& e) {
15859       {
15860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15861       };
15862     } catch (Dali::DaliException e) {
15863       {
15864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15865       };
15866     } catch (...) {
15867       {
15868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15869       };
15870     }
15871   }
15872
15873   jresult = (void *)result;
15874   return jresult;
15875 }
15876
15877
15878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15879   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15880
15881   arg1 = (Dali::Property::Map *)jarg1;
15882   {
15883     try {
15884       delete arg1;
15885     } catch (std::out_of_range& e) {
15886       {
15887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15888       };
15889     } catch (std::exception& e) {
15890       {
15891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15892       };
15893     } catch (Dali::DaliException e) {
15894       {
15895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15896       };
15897     } catch (...) {
15898       {
15899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15900       };
15901     }
15902   }
15903
15904 }
15905
15906
15907 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15908   unsigned long jresult ;
15909   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15910   Dali::Property::Map::SizeType result;
15911
15912   arg1 = (Dali::Property::Map *)jarg1;
15913   {
15914     try {
15915       result = ((Dali::Property::Map const *)arg1)->Count();
15916     } catch (std::out_of_range& e) {
15917       {
15918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15919       };
15920     } catch (std::exception& e) {
15921       {
15922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15923       };
15924     } catch (Dali::DaliException e) {
15925       {
15926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15927       };
15928     } catch (...) {
15929       {
15930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15931       };
15932     }
15933   }
15934
15935   jresult = (unsigned long)result;
15936   return jresult;
15937 }
15938
15939
15940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15941   unsigned int jresult ;
15942   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15943   bool result;
15944
15945   arg1 = (Dali::Property::Map *)jarg1;
15946   {
15947     try {
15948       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15949     } catch (std::out_of_range& e) {
15950       {
15951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15952       };
15953     } catch (std::exception& e) {
15954       {
15955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15956       };
15957     } catch (Dali::DaliException e) {
15958       {
15959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15960       };
15961     } catch (...) {
15962       {
15963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15964       };
15965     }
15966   }
15967
15968   jresult = result;
15969   return jresult;
15970 }
15971
15972
15973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15974   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15975   char *arg2 = (char *) 0 ;
15976   Dali::Property::Value *arg3 = 0 ;
15977
15978   arg1 = (Dali::Property::Map *)jarg1;
15979   arg2 = (char *)jarg2;
15980   arg3 = (Dali::Property::Value *)jarg3;
15981   if (!arg3) {
15982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15983     return ;
15984   }
15985   {
15986     try {
15987       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15988     } catch (std::out_of_range& e) {
15989       {
15990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15991       };
15992     } catch (std::exception& e) {
15993       {
15994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15995       };
15996     } catch (Dali::DaliException e) {
15997       {
15998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15999       };
16000     } catch (...) {
16001       {
16002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16003       };
16004     }
16005   }
16006
16007 }
16008
16009
16010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16011   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16012   Dali::Property::Index arg2 ;
16013   Dali::Property::Value *arg3 = 0 ;
16014
16015   arg1 = (Dali::Property::Map *)jarg1;
16016   arg2 = (Dali::Property::Index)jarg2;
16017   arg3 = (Dali::Property::Value *)jarg3;
16018   if (!arg3) {
16019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16020     return ;
16021   }
16022   {
16023     try {
16024       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16025     } catch (std::out_of_range& e) {
16026       {
16027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16028       };
16029     } catch (std::exception& e) {
16030       {
16031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16032       };
16033     } catch (Dali::DaliException e) {
16034       {
16035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16036       };
16037     } catch (...) {
16038       {
16039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16040       };
16041     }
16042   }
16043
16044 }
16045
16046
16047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16048   void * jresult ;
16049   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16050   char *arg2 = (char *) 0 ;
16051   Dali::Property::Value *arg3 = 0 ;
16052   Dali::Property::Map *result = 0 ;
16053
16054   arg1 = (Dali::Property::Map *)jarg1;
16055   arg2 = (char *)jarg2;
16056   arg3 = (Dali::Property::Value *)jarg3;
16057   if (!arg3) {
16058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16059     return 0;
16060   }
16061   {
16062     try {
16063       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16064     } catch (std::out_of_range& e) {
16065       {
16066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16067       };
16068     } catch (std::exception& e) {
16069       {
16070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16071       };
16072     } catch (Dali::DaliException e) {
16073       {
16074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16075       };
16076     } catch (...) {
16077       {
16078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16079       };
16080     }
16081   }
16082
16083   jresult = (void *)result;
16084   return jresult;
16085 }
16086
16087
16088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16089   void * jresult ;
16090   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16091   Dali::Property::Index arg2 ;
16092   Dali::Property::Value *arg3 = 0 ;
16093   Dali::Property::Map *result = 0 ;
16094
16095   arg1 = (Dali::Property::Map *)jarg1;
16096   arg2 = (Dali::Property::Index)jarg2;
16097   arg3 = (Dali::Property::Value *)jarg3;
16098   if (!arg3) {
16099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16100     return 0;
16101   }
16102   {
16103     try {
16104       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16105     } catch (std::out_of_range& e) {
16106       {
16107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16108       };
16109     } catch (std::exception& e) {
16110       {
16111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16112       };
16113     } catch (Dali::DaliException e) {
16114       {
16115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16116       };
16117     } catch (...) {
16118       {
16119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16120       };
16121     }
16122   }
16123
16124   jresult = (void *)result;
16125   return jresult;
16126 }
16127
16128
16129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16130   void * jresult ;
16131   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16132   Dali::Property::Map::SizeType arg2 ;
16133   Dali::Property::Value *result = 0 ;
16134
16135   arg1 = (Dali::Property::Map *)jarg1;
16136   arg2 = (Dali::Property::Map::SizeType)jarg2;
16137   {
16138     try {
16139       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16140     } catch (std::out_of_range& e) {
16141       {
16142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16143       };
16144     } catch (std::exception& e) {
16145       {
16146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16147       };
16148     } catch (Dali::DaliException e) {
16149       {
16150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16151       };
16152     } catch (...) {
16153       {
16154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16155       };
16156     }
16157   }
16158
16159   jresult = (void *)result;
16160   return jresult;
16161 }
16162
16163
16164 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16165   char * jresult ;
16166   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16167   Dali::Property::Map::SizeType arg2 ;
16168   std::string *result = 0 ;
16169
16170   arg1 = (Dali::Property::Map *)jarg1;
16171   arg2 = (Dali::Property::Map::SizeType)jarg2;
16172   {
16173     try {
16174       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16175     } catch (std::out_of_range& e) {
16176       {
16177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16178       };
16179     } catch (std::exception& e) {
16180       {
16181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16182       };
16183     } catch (Dali::DaliException e) {
16184       {
16185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16186       };
16187     } catch (...) {
16188       {
16189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16190       };
16191     }
16192   }
16193
16194   jresult = SWIG_csharp_string_callback(result->c_str());
16195   return jresult;
16196 }
16197
16198
16199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16200   void * jresult ;
16201   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16202   Dali::Property::Map::SizeType arg2 ;
16203   SwigValueWrapper< Dali::Property::Key > result;
16204
16205   arg1 = (Dali::Property::Map *)jarg1;
16206   arg2 = (Dali::Property::Map::SizeType)jarg2;
16207   {
16208     try {
16209       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16210     } catch (std::out_of_range& e) {
16211       {
16212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16213       };
16214     } catch (std::exception& e) {
16215       {
16216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16217       };
16218     } catch (Dali::DaliException e) {
16219       {
16220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16221       };
16222     } catch (...) {
16223       {
16224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16225       };
16226     }
16227   }
16228
16229   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16230   return jresult;
16231 }
16232
16233
16234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16235   void * jresult ;
16236   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16237   Dali::Property::Map::SizeType arg2 ;
16238   StringValuePair *result = 0 ;
16239
16240   arg1 = (Dali::Property::Map *)jarg1;
16241   arg2 = (Dali::Property::Map::SizeType)jarg2;
16242   {
16243     try {
16244       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16245     } catch (std::out_of_range& e) {
16246       {
16247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16248       };
16249     } catch (std::exception& e) {
16250       {
16251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16252       };
16253     } catch (Dali::DaliException e) {
16254       {
16255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16256       };
16257     } catch (...) {
16258       {
16259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16260       };
16261     }
16262   }
16263
16264   jresult = (void *)result;
16265   return jresult;
16266 }
16267
16268
16269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16270   void * jresult ;
16271   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16272   char *arg2 = (char *) 0 ;
16273   Dali::Property::Value *result = 0 ;
16274
16275   arg1 = (Dali::Property::Map *)jarg1;
16276   arg2 = (char *)jarg2;
16277   {
16278     try {
16279       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16280     } catch (std::out_of_range& e) {
16281       {
16282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16283       };
16284     } catch (std::exception& e) {
16285       {
16286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16287       };
16288     } catch (Dali::DaliException e) {
16289       {
16290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16291       };
16292     } catch (...) {
16293       {
16294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16295       };
16296     }
16297   }
16298
16299   jresult = (void *)result;
16300   return jresult;
16301 }
16302
16303
16304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16305   void * jresult ;
16306   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16307   Dali::Property::Index arg2 ;
16308   Dali::Property::Value *result = 0 ;
16309
16310   arg1 = (Dali::Property::Map *)jarg1;
16311   arg2 = (Dali::Property::Index)jarg2;
16312   {
16313     try {
16314       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16315     } catch (std::out_of_range& e) {
16316       {
16317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16318       };
16319     } catch (std::exception& e) {
16320       {
16321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16322       };
16323     } catch (Dali::DaliException e) {
16324       {
16325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16326       };
16327     } catch (...) {
16328       {
16329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16330       };
16331     }
16332   }
16333
16334   jresult = (void *)result;
16335   return jresult;
16336 }
16337
16338
16339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16340   void * jresult ;
16341   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16342   Dali::Property::Index arg2 ;
16343   std::string *arg3 = 0 ;
16344   Dali::Property::Value *result = 0 ;
16345
16346   arg1 = (Dali::Property::Map *)jarg1;
16347   arg2 = (Dali::Property::Index)jarg2;
16348   if (!jarg3) {
16349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16350     return 0;
16351   }
16352   std::string arg3_str(jarg3);
16353   arg3 = &arg3_str;
16354   {
16355     try {
16356       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16357     } catch (std::out_of_range& e) {
16358       {
16359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16360       };
16361     } catch (std::exception& e) {
16362       {
16363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16364       };
16365     } catch (Dali::DaliException e) {
16366       {
16367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16368       };
16369     } catch (...) {
16370       {
16371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16372       };
16373     }
16374   }
16375
16376   jresult = (void *)result;
16377
16378   //argout typemap for const std::string&
16379
16380   return jresult;
16381 }
16382
16383
16384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16385   void * jresult ;
16386   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16387   std::string *arg2 = 0 ;
16388   Dali::Property::Type arg3 ;
16389   Dali::Property::Value *result = 0 ;
16390
16391   arg1 = (Dali::Property::Map *)jarg1;
16392   if (!jarg2) {
16393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16394     return 0;
16395   }
16396   std::string arg2_str(jarg2);
16397   arg2 = &arg2_str;
16398   arg3 = (Dali::Property::Type)jarg3;
16399   {
16400     try {
16401       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16402     } catch (std::out_of_range& e) {
16403       {
16404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16405       };
16406     } catch (std::exception& e) {
16407       {
16408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16409       };
16410     } catch (Dali::DaliException e) {
16411       {
16412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16413       };
16414     } catch (...) {
16415       {
16416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16417       };
16418     }
16419   }
16420
16421   jresult = (void *)result;
16422
16423   //argout typemap for const std::string&
16424
16425   return jresult;
16426 }
16427
16428
16429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16430   void * jresult ;
16431   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16432   Dali::Property::Index arg2 ;
16433   Dali::Property::Type arg3 ;
16434   Dali::Property::Value *result = 0 ;
16435
16436   arg1 = (Dali::Property::Map *)jarg1;
16437   arg2 = (Dali::Property::Index)jarg2;
16438   arg3 = (Dali::Property::Type)jarg3;
16439   {
16440     try {
16441       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16442     } catch (std::out_of_range& e) {
16443       {
16444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16445       };
16446     } catch (std::exception& e) {
16447       {
16448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16449       };
16450     } catch (Dali::DaliException e) {
16451       {
16452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16453       };
16454     } catch (...) {
16455       {
16456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16457       };
16458     }
16459   }
16460
16461   jresult = (void *)result;
16462   return jresult;
16463 }
16464
16465
16466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16467   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16468
16469   arg1 = (Dali::Property::Map *)jarg1;
16470   {
16471     try {
16472       (arg1)->Clear();
16473     } catch (std::out_of_range& e) {
16474       {
16475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16476       };
16477     } catch (std::exception& e) {
16478       {
16479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16480       };
16481     } catch (Dali::DaliException e) {
16482       {
16483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16484       };
16485     } catch (...) {
16486       {
16487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16488       };
16489     }
16490   }
16491
16492 }
16493
16494
16495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16496   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16497   Dali::Property::Map *arg2 = 0 ;
16498
16499   arg1 = (Dali::Property::Map *)jarg1;
16500   arg2 = (Dali::Property::Map *)jarg2;
16501   if (!arg2) {
16502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16503     return ;
16504   }
16505   {
16506     try {
16507       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16508     } catch (std::out_of_range& e) {
16509       {
16510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16511       };
16512     } catch (std::exception& e) {
16513       {
16514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16515       };
16516     } catch (Dali::DaliException e) {
16517       {
16518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16519       };
16520     } catch (...) {
16521       {
16522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16523       };
16524     }
16525   }
16526
16527 }
16528
16529
16530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16531   void * jresult ;
16532   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16533   std::string *arg2 = 0 ;
16534   Dali::Property::Value *result = 0 ;
16535
16536   arg1 = (Dali::Property::Map *)jarg1;
16537   if (!jarg2) {
16538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16539     return 0;
16540   }
16541   std::string arg2_str(jarg2);
16542   arg2 = &arg2_str;
16543   {
16544     try {
16545       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16546     } catch (std::out_of_range& e) {
16547       {
16548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16549       };
16550     } catch (std::exception& e) {
16551       {
16552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16553       };
16554     } catch (Dali::DaliException e) {
16555       {
16556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16557       };
16558     } catch (...) {
16559       {
16560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16561       };
16562     }
16563   }
16564
16565   jresult = (void *)result;
16566
16567   //argout typemap for const std::string&
16568
16569   return jresult;
16570 }
16571
16572
16573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16574   void * jresult ;
16575   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16576   Dali::Property::Index arg2 ;
16577   Dali::Property::Value *result = 0 ;
16578
16579   arg1 = (Dali::Property::Map *)jarg1;
16580   arg2 = (Dali::Property::Index)jarg2;
16581   {
16582     try {
16583       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16584     } catch (std::out_of_range& e) {
16585       {
16586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16587       };
16588     } catch (std::exception& e) {
16589       {
16590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16591       };
16592     } catch (Dali::DaliException e) {
16593       {
16594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16595       };
16596     } catch (...) {
16597       {
16598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16599       };
16600     }
16601   }
16602
16603   jresult = (void *)result;
16604   return jresult;
16605 }
16606
16607
16608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16609   void * jresult ;
16610   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16611   Dali::Property::Map *arg2 = 0 ;
16612   Dali::Property::Map *result = 0 ;
16613
16614   arg1 = (Dali::Property::Map *)jarg1;
16615   arg2 = (Dali::Property::Map *)jarg2;
16616   if (!arg2) {
16617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16618     return 0;
16619   }
16620   {
16621     try {
16622       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16623     } catch (std::out_of_range& e) {
16624       {
16625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16626       };
16627     } catch (std::exception& e) {
16628       {
16629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16630       };
16631     } catch (Dali::DaliException e) {
16632       {
16633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16634       };
16635     } catch (...) {
16636       {
16637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16638       };
16639     }
16640   }
16641
16642   jresult = (void *)result;
16643   return jresult;
16644 }
16645
16646
16647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16648   void * jresult ;
16649   Dali::Property::Value *result = 0 ;
16650
16651   {
16652     try {
16653       result = (Dali::Property::Value *)new Dali::Property::Value();
16654     } catch (std::out_of_range& e) {
16655       {
16656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16657       };
16658     } catch (std::exception& e) {
16659       {
16660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16661       };
16662     } catch (Dali::DaliException e) {
16663       {
16664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16665       };
16666     } catch (...) {
16667       {
16668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16669       };
16670     }
16671   }
16672
16673   jresult = (void *)result;
16674   return jresult;
16675 }
16676
16677
16678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16679   void * jresult ;
16680   bool arg1 ;
16681   Dali::Property::Value *result = 0 ;
16682
16683   arg1 = jarg1 ? true : false;
16684   {
16685     try {
16686       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16687     } catch (std::out_of_range& e) {
16688       {
16689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16690       };
16691     } catch (std::exception& e) {
16692       {
16693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16694       };
16695     } catch (Dali::DaliException e) {
16696       {
16697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16698       };
16699     } catch (...) {
16700       {
16701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16702       };
16703     }
16704   }
16705
16706   jresult = (void *)result;
16707   return jresult;
16708 }
16709
16710
16711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16712   void * jresult ;
16713   int arg1 ;
16714   Dali::Property::Value *result = 0 ;
16715
16716   arg1 = (int)jarg1;
16717   {
16718     try {
16719       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16720     } catch (std::out_of_range& e) {
16721       {
16722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16723       };
16724     } catch (std::exception& e) {
16725       {
16726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16727       };
16728     } catch (Dali::DaliException e) {
16729       {
16730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16731       };
16732     } catch (...) {
16733       {
16734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16735       };
16736     }
16737   }
16738
16739   jresult = (void *)result;
16740   return jresult;
16741 }
16742
16743
16744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16745   void * jresult ;
16746   float arg1 ;
16747   Dali::Property::Value *result = 0 ;
16748
16749   arg1 = (float)jarg1;
16750   {
16751     try {
16752       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16753     } catch (std::out_of_range& e) {
16754       {
16755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16756       };
16757     } catch (std::exception& e) {
16758       {
16759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16760       };
16761     } catch (Dali::DaliException e) {
16762       {
16763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16764       };
16765     } catch (...) {
16766       {
16767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16768       };
16769     }
16770   }
16771
16772   jresult = (void *)result;
16773   return jresult;
16774 }
16775
16776
16777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16778   void * jresult ;
16779   Dali::Vector2 *arg1 = 0 ;
16780   Dali::Property::Value *result = 0 ;
16781
16782   arg1 = (Dali::Vector2 *)jarg1;
16783   if (!arg1) {
16784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16785     return 0;
16786   }
16787   {
16788     try {
16789       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16790     } catch (std::out_of_range& e) {
16791       {
16792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16793       };
16794     } catch (std::exception& e) {
16795       {
16796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16797       };
16798     } catch (Dali::DaliException e) {
16799       {
16800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16801       };
16802     } catch (...) {
16803       {
16804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16805       };
16806     }
16807   }
16808
16809   jresult = (void *)result;
16810   return jresult;
16811 }
16812
16813
16814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16815   void * jresult ;
16816   Dali::Vector3 *arg1 = 0 ;
16817   Dali::Property::Value *result = 0 ;
16818
16819   arg1 = (Dali::Vector3 *)jarg1;
16820   if (!arg1) {
16821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16822     return 0;
16823   }
16824   {
16825     try {
16826       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16827     } catch (std::out_of_range& e) {
16828       {
16829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16830       };
16831     } catch (std::exception& e) {
16832       {
16833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16834       };
16835     } catch (Dali::DaliException e) {
16836       {
16837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16838       };
16839     } catch (...) {
16840       {
16841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16842       };
16843     }
16844   }
16845
16846   jresult = (void *)result;
16847   return jresult;
16848 }
16849
16850
16851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16852   void * jresult ;
16853   Dali::Vector4 *arg1 = 0 ;
16854   Dali::Property::Value *result = 0 ;
16855
16856   arg1 = (Dali::Vector4 *)jarg1;
16857   if (!arg1) {
16858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16859     return 0;
16860   }
16861   {
16862     try {
16863       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16864     } catch (std::out_of_range& e) {
16865       {
16866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16867       };
16868     } catch (std::exception& e) {
16869       {
16870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16871       };
16872     } catch (Dali::DaliException e) {
16873       {
16874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16875       };
16876     } catch (...) {
16877       {
16878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16879       };
16880     }
16881   }
16882
16883   jresult = (void *)result;
16884   return jresult;
16885 }
16886
16887
16888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16889   void * jresult ;
16890   Dali::Matrix3 *arg1 = 0 ;
16891   Dali::Property::Value *result = 0 ;
16892
16893   arg1 = (Dali::Matrix3 *)jarg1;
16894   if (!arg1) {
16895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16896     return 0;
16897   }
16898   {
16899     try {
16900       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16901     } catch (std::out_of_range& e) {
16902       {
16903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16904       };
16905     } catch (std::exception& e) {
16906       {
16907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16908       };
16909     } catch (Dali::DaliException e) {
16910       {
16911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16912       };
16913     } catch (...) {
16914       {
16915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16916       };
16917     }
16918   }
16919
16920   jresult = (void *)result;
16921   return jresult;
16922 }
16923
16924
16925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16926   void * jresult ;
16927   Dali::Matrix *arg1 = 0 ;
16928   Dali::Property::Value *result = 0 ;
16929
16930   arg1 = (Dali::Matrix *)jarg1;
16931   if (!arg1) {
16932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16933     return 0;
16934   }
16935   {
16936     try {
16937       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16938     } catch (std::out_of_range& e) {
16939       {
16940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16941       };
16942     } catch (std::exception& e) {
16943       {
16944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16945       };
16946     } catch (Dali::DaliException e) {
16947       {
16948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16949       };
16950     } catch (...) {
16951       {
16952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16953       };
16954     }
16955   }
16956
16957   jresult = (void *)result;
16958   return jresult;
16959 }
16960
16961
16962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16963   void * jresult ;
16964   Dali::Rect< int > *arg1 = 0 ;
16965   Dali::Property::Value *result = 0 ;
16966
16967   arg1 = (Dali::Rect< int > *)jarg1;
16968   if (!arg1) {
16969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16970     return 0;
16971   }
16972   {
16973     try {
16974       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16975     } catch (std::out_of_range& e) {
16976       {
16977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16978       };
16979     } catch (std::exception& e) {
16980       {
16981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16982       };
16983     } catch (Dali::DaliException e) {
16984       {
16985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16986       };
16987     } catch (...) {
16988       {
16989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16990       };
16991     }
16992   }
16993
16994   jresult = (void *)result;
16995   return jresult;
16996 }
16997
16998
16999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17000   void * jresult ;
17001   Dali::AngleAxis *arg1 = 0 ;
17002   Dali::Property::Value *result = 0 ;
17003
17004   arg1 = (Dali::AngleAxis *)jarg1;
17005   if (!arg1) {
17006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17007     return 0;
17008   }
17009   {
17010     try {
17011       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17012     } catch (std::out_of_range& e) {
17013       {
17014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17015       };
17016     } catch (std::exception& e) {
17017       {
17018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17019       };
17020     } catch (Dali::DaliException e) {
17021       {
17022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17023       };
17024     } catch (...) {
17025       {
17026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17027       };
17028     }
17029   }
17030
17031   jresult = (void *)result;
17032   return jresult;
17033 }
17034
17035
17036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17037   void * jresult ;
17038   Dali::Quaternion *arg1 = 0 ;
17039   Dali::Property::Value *result = 0 ;
17040
17041   arg1 = (Dali::Quaternion *)jarg1;
17042   if (!arg1) {
17043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17044     return 0;
17045   }
17046   {
17047     try {
17048       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17049     } catch (std::out_of_range& e) {
17050       {
17051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17052       };
17053     } catch (std::exception& e) {
17054       {
17055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17056       };
17057     } catch (Dali::DaliException e) {
17058       {
17059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17060       };
17061     } catch (...) {
17062       {
17063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17064       };
17065     }
17066   }
17067
17068   jresult = (void *)result;
17069   return jresult;
17070 }
17071
17072
17073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17074   void * jresult ;
17075   std::string *arg1 = 0 ;
17076   Dali::Property::Value *result = 0 ;
17077
17078   if (!jarg1) {
17079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17080     return 0;
17081   }
17082   std::string arg1_str(jarg1);
17083   arg1 = &arg1_str;
17084   {
17085     try {
17086       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17087     } catch (std::out_of_range& e) {
17088       {
17089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17090       };
17091     } catch (std::exception& e) {
17092       {
17093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17094       };
17095     } catch (Dali::DaliException e) {
17096       {
17097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17098       };
17099     } catch (...) {
17100       {
17101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17102       };
17103     }
17104   }
17105
17106   jresult = (void *)result;
17107
17108   //argout typemap for const std::string&
17109
17110   return jresult;
17111 }
17112
17113
17114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17115   void * jresult ;
17116   Dali::Property::Array *arg1 = 0 ;
17117   Dali::Property::Value *result = 0 ;
17118
17119   arg1 = (Dali::Property::Array *)jarg1;
17120   if (!arg1) {
17121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17122     return 0;
17123   }
17124   {
17125     try {
17126       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17127     } catch (std::out_of_range& e) {
17128       {
17129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17130       };
17131     } catch (std::exception& e) {
17132       {
17133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17134       };
17135     } catch (Dali::DaliException e) {
17136       {
17137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17138       };
17139     } catch (...) {
17140       {
17141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17142       };
17143     }
17144   }
17145
17146   jresult = (void *)result;
17147   return jresult;
17148 }
17149
17150
17151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17152   void * jresult ;
17153   Dali::Property::Map *arg1 = 0 ;
17154   Dali::Property::Value *result = 0 ;
17155
17156   arg1 = (Dali::Property::Map *)jarg1;
17157   if (!arg1) {
17158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17159     return 0;
17160   }
17161   {
17162     try {
17163       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17164     } catch (std::out_of_range& e) {
17165       {
17166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17167       };
17168     } catch (std::exception& e) {
17169       {
17170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17171       };
17172     } catch (Dali::DaliException e) {
17173       {
17174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17175       };
17176     } catch (...) {
17177       {
17178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17179       };
17180     }
17181   }
17182
17183   jresult = (void *)result;
17184   return jresult;
17185 }
17186
17187
17188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17189   void * jresult ;
17190   Extents *arg1 = 0 ;
17191   Dali::Property::Value *result = 0 ;
17192
17193   arg1 = (Extents *)jarg1;
17194   if (!arg1) {
17195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17196     return 0;
17197   }
17198   {
17199     try {
17200       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17201     } catch (std::out_of_range& e) {
17202       {
17203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17204       };
17205     } catch (std::exception& e) {
17206       {
17207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17208       };
17209     } catch (...) {
17210       {
17211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17212       };
17213     }
17214   }
17215   jresult = (void *)result;
17216   return jresult;
17217 }
17218
17219
17220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17221   void * jresult ;
17222   Dali::Property::Type arg1 ;
17223   Dali::Property::Value *result = 0 ;
17224
17225   arg1 = (Dali::Property::Type)jarg1;
17226   {
17227     try {
17228       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17229     } catch (std::out_of_range& e) {
17230       {
17231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17232       };
17233     } catch (std::exception& e) {
17234       {
17235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17236       };
17237     } catch (Dali::DaliException e) {
17238       {
17239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17240       };
17241     } catch (...) {
17242       {
17243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17244       };
17245     }
17246   }
17247
17248   jresult = (void *)result;
17249   return jresult;
17250 }
17251
17252
17253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17254   void * jresult ;
17255   Dali::Property::Value *arg1 = 0 ;
17256   Dali::Property::Value *result = 0 ;
17257
17258   arg1 = (Dali::Property::Value *)jarg1;
17259   if (!arg1) {
17260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17261     return 0;
17262   }
17263   {
17264     try {
17265       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17266     } catch (std::out_of_range& e) {
17267       {
17268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17269       };
17270     } catch (std::exception& e) {
17271       {
17272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17273       };
17274     } catch (Dali::DaliException e) {
17275       {
17276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17277       };
17278     } catch (...) {
17279       {
17280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17281       };
17282     }
17283   }
17284
17285   jresult = (void *)result;
17286   return jresult;
17287 }
17288
17289
17290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17291   void * jresult ;
17292   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17293   Dali::Property::Value *arg2 = 0 ;
17294   Dali::Property::Value *result = 0 ;
17295
17296   arg1 = (Dali::Property::Value *)jarg1;
17297   arg2 = (Dali::Property::Value *)jarg2;
17298   if (!arg2) {
17299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17300     return 0;
17301   }
17302   {
17303     try {
17304       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17305     } catch (std::out_of_range& e) {
17306       {
17307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17308       };
17309     } catch (std::exception& e) {
17310       {
17311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17312       };
17313     } catch (Dali::DaliException e) {
17314       {
17315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17316       };
17317     } catch (...) {
17318       {
17319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17320       };
17321     }
17322   }
17323
17324   jresult = (void *)result;
17325   return jresult;
17326 }
17327
17328
17329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17330   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17331
17332   arg1 = (Dali::Property::Value *)jarg1;
17333   {
17334     try {
17335       delete arg1;
17336     } catch (std::out_of_range& e) {
17337       {
17338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17339       };
17340     } catch (std::exception& e) {
17341       {
17342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17343       };
17344     } catch (Dali::DaliException e) {
17345       {
17346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17347       };
17348     } catch (...) {
17349       {
17350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17351       };
17352     }
17353   }
17354
17355 }
17356
17357
17358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17359   int jresult ;
17360   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17361   Dali::Property::Type result;
17362
17363   arg1 = (Dali::Property::Value *)jarg1;
17364   {
17365     try {
17366       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17367     } catch (std::out_of_range& e) {
17368       {
17369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17370       };
17371     } catch (std::exception& e) {
17372       {
17373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17374       };
17375     } catch (Dali::DaliException e) {
17376       {
17377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17378       };
17379     } catch (...) {
17380       {
17381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17382       };
17383     }
17384   }
17385
17386   jresult = (int)result;
17387   return jresult;
17388 }
17389
17390
17391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17392   unsigned int jresult ;
17393   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17394   bool *arg2 = 0 ;
17395   bool result;
17396
17397   arg1 = (Dali::Property::Value *)jarg1;
17398   arg2 = (bool *)jarg2;
17399   {
17400     try {
17401       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17402     } catch (std::out_of_range& e) {
17403       {
17404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17405       };
17406     } catch (std::exception& e) {
17407       {
17408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17409       };
17410     } catch (Dali::DaliException e) {
17411       {
17412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17413       };
17414     } catch (...) {
17415       {
17416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17417       };
17418     }
17419   }
17420
17421   jresult = result;
17422   return jresult;
17423 }
17424
17425
17426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17427   unsigned int jresult ;
17428   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17429   float *arg2 = 0 ;
17430   bool result;
17431
17432   arg1 = (Dali::Property::Value *)jarg1;
17433   arg2 = (float *)jarg2;
17434   {
17435     try {
17436       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17437     } catch (std::out_of_range& e) {
17438       {
17439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17440       };
17441     } catch (std::exception& e) {
17442       {
17443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17444       };
17445     } catch (Dali::DaliException e) {
17446       {
17447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17448       };
17449     } catch (...) {
17450       {
17451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17452       };
17453     }
17454   }
17455
17456   jresult = result;
17457   return jresult;
17458 }
17459
17460
17461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17462   unsigned int jresult ;
17463   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17464   int *arg2 = 0 ;
17465   bool result;
17466
17467   arg1 = (Dali::Property::Value *)jarg1;
17468   arg2 = (int *)jarg2;
17469   {
17470     try {
17471       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17472     } catch (std::out_of_range& e) {
17473       {
17474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17475       };
17476     } catch (std::exception& e) {
17477       {
17478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17479       };
17480     } catch (Dali::DaliException e) {
17481       {
17482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17483       };
17484     } catch (...) {
17485       {
17486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17487       };
17488     }
17489   }
17490
17491   jresult = result;
17492   return jresult;
17493 }
17494
17495
17496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17497   unsigned int jresult ;
17498   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17499   Dali::Rect< int > *arg2 = 0 ;
17500   bool result;
17501
17502   arg1 = (Dali::Property::Value *)jarg1;
17503   arg2 = (Dali::Rect< int > *)jarg2;
17504   if (!arg2) {
17505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17506     return 0;
17507   }
17508   {
17509     try {
17510       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17511     } catch (std::out_of_range& e) {
17512       {
17513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17514       };
17515     } catch (std::exception& e) {
17516       {
17517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17518       };
17519     } catch (Dali::DaliException e) {
17520       {
17521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17522       };
17523     } catch (...) {
17524       {
17525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17526       };
17527     }
17528   }
17529
17530   jresult = result;
17531   return jresult;
17532 }
17533
17534
17535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17536   unsigned int jresult ;
17537   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17538   Dali::Vector2 *arg2 = 0 ;
17539   bool result;
17540
17541   arg1 = (Dali::Property::Value *)jarg1;
17542   arg2 = (Dali::Vector2 *)jarg2;
17543   if (!arg2) {
17544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17545     return 0;
17546   }
17547   {
17548     try {
17549       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17550     } catch (std::out_of_range& e) {
17551       {
17552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17553       };
17554     } catch (std::exception& e) {
17555       {
17556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17557       };
17558     } catch (Dali::DaliException e) {
17559       {
17560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17561       };
17562     } catch (...) {
17563       {
17564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17565       };
17566     }
17567   }
17568
17569   jresult = result;
17570   return jresult;
17571 }
17572
17573
17574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17575   unsigned int jresult ;
17576   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17577   Dali::Vector3 *arg2 = 0 ;
17578   bool result;
17579
17580   arg1 = (Dali::Property::Value *)jarg1;
17581   arg2 = (Dali::Vector3 *)jarg2;
17582   if (!arg2) {
17583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17584     return 0;
17585   }
17586   {
17587     try {
17588       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17589     } catch (std::out_of_range& e) {
17590       {
17591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17592       };
17593     } catch (std::exception& e) {
17594       {
17595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17596       };
17597     } catch (Dali::DaliException e) {
17598       {
17599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17600       };
17601     } catch (...) {
17602       {
17603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17604       };
17605     }
17606   }
17607
17608   jresult = result;
17609   return jresult;
17610 }
17611
17612
17613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17614   unsigned int jresult ;
17615   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17616   Dali::Vector4 *arg2 = 0 ;
17617   bool result;
17618
17619   arg1 = (Dali::Property::Value *)jarg1;
17620   arg2 = (Dali::Vector4 *)jarg2;
17621   if (!arg2) {
17622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17623     return 0;
17624   }
17625   {
17626     try {
17627       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17628     } catch (std::out_of_range& e) {
17629       {
17630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17631       };
17632     } catch (std::exception& e) {
17633       {
17634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17635       };
17636     } catch (Dali::DaliException e) {
17637       {
17638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17639       };
17640     } catch (...) {
17641       {
17642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17643       };
17644     }
17645   }
17646
17647   jresult = result;
17648   return jresult;
17649 }
17650
17651
17652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17653   unsigned int jresult ;
17654   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17655   Dali::Matrix3 *arg2 = 0 ;
17656   bool result;
17657
17658   arg1 = (Dali::Property::Value *)jarg1;
17659   arg2 = (Dali::Matrix3 *)jarg2;
17660   if (!arg2) {
17661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17662     return 0;
17663   }
17664   {
17665     try {
17666       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17667     } catch (std::out_of_range& e) {
17668       {
17669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17670       };
17671     } catch (std::exception& e) {
17672       {
17673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17674       };
17675     } catch (Dali::DaliException e) {
17676       {
17677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17678       };
17679     } catch (...) {
17680       {
17681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17682       };
17683     }
17684   }
17685
17686   jresult = result;
17687   return jresult;
17688 }
17689
17690
17691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17692   unsigned int jresult ;
17693   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17694   Dali::Matrix *arg2 = 0 ;
17695   bool result;
17696
17697   arg1 = (Dali::Property::Value *)jarg1;
17698   arg2 = (Dali::Matrix *)jarg2;
17699   if (!arg2) {
17700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17701     return 0;
17702   }
17703   {
17704     try {
17705       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17706     } catch (std::out_of_range& e) {
17707       {
17708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17709       };
17710     } catch (std::exception& e) {
17711       {
17712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17713       };
17714     } catch (Dali::DaliException e) {
17715       {
17716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17717       };
17718     } catch (...) {
17719       {
17720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17721       };
17722     }
17723   }
17724
17725   jresult = result;
17726   return jresult;
17727 }
17728
17729
17730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17731   unsigned int jresult ;
17732   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17733   Dali::AngleAxis *arg2 = 0 ;
17734   bool result;
17735
17736   arg1 = (Dali::Property::Value *)jarg1;
17737   arg2 = (Dali::AngleAxis *)jarg2;
17738   if (!arg2) {
17739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17740     return 0;
17741   }
17742   {
17743     try {
17744       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17745     } catch (std::out_of_range& e) {
17746       {
17747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17748       };
17749     } catch (std::exception& e) {
17750       {
17751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17752       };
17753     } catch (Dali::DaliException e) {
17754       {
17755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17756       };
17757     } catch (...) {
17758       {
17759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17760       };
17761     }
17762   }
17763
17764   jresult = result;
17765   return jresult;
17766 }
17767
17768
17769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17770   unsigned int jresult ;
17771   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17772   Dali::Quaternion *arg2 = 0 ;
17773   bool result;
17774
17775   arg1 = (Dali::Property::Value *)jarg1;
17776   arg2 = (Dali::Quaternion *)jarg2;
17777   if (!arg2) {
17778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17779     return 0;
17780   }
17781   {
17782     try {
17783       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17784     } catch (std::out_of_range& e) {
17785       {
17786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17787       };
17788     } catch (std::exception& e) {
17789       {
17790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17791       };
17792     } catch (Dali::DaliException e) {
17793       {
17794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17795       };
17796     } catch (...) {
17797       {
17798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17799       };
17800     }
17801   }
17802
17803   jresult = result;
17804   return jresult;
17805 }
17806
17807
17808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17809   unsigned int jresult ;
17810   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17811   std::string *arg2 = 0 ;
17812   bool result;
17813
17814   arg1 = (Dali::Property::Value *)jarg1;
17815
17816   //typemap in
17817   std::string temp;
17818   arg2 = &temp;
17819
17820   {
17821     try {
17822       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17823     } catch (std::out_of_range& e) {
17824       {
17825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17826       };
17827     } catch (std::exception& e) {
17828       {
17829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17830       };
17831     } catch (Dali::DaliException e) {
17832       {
17833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17834       };
17835     } catch (...) {
17836       {
17837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17838       };
17839     }
17840   }
17841
17842   jresult = result;
17843
17844   //Typemap argout in c++ file.
17845   //This will convert c++ string to c# string
17846   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17847
17848   return jresult;
17849 }
17850
17851
17852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17853   unsigned int jresult ;
17854   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17855   Dali::Property::Array *arg2 = 0 ;
17856   bool result;
17857
17858   arg1 = (Dali::Property::Value *)jarg1;
17859   arg2 = (Dali::Property::Array *)jarg2;
17860   if (!arg2) {
17861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17862     return 0;
17863   }
17864   {
17865     try {
17866       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17867     } catch (std::out_of_range& e) {
17868       {
17869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17870       };
17871     } catch (std::exception& e) {
17872       {
17873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17874       };
17875     } catch (Dali::DaliException e) {
17876       {
17877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17878       };
17879     } catch (...) {
17880       {
17881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17882       };
17883     }
17884   }
17885
17886   jresult = result;
17887   return jresult;
17888 }
17889
17890
17891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17892   unsigned int jresult ;
17893   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17894   Dali::Property::Map *arg2 = 0 ;
17895   bool result;
17896
17897   arg1 = (Dali::Property::Value *)jarg1;
17898   arg2 = (Dali::Property::Map *)jarg2;
17899   if (!arg2) {
17900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17901     return 0;
17902   }
17903   {
17904     try {
17905       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17906     } catch (std::out_of_range& e) {
17907       {
17908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17909       };
17910     } catch (std::exception& e) {
17911       {
17912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17913       };
17914     } catch (Dali::DaliException e) {
17915       {
17916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17917       };
17918     } catch (...) {
17919       {
17920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17921       };
17922     }
17923   }
17924
17925   jresult = result;
17926   return jresult;
17927 }
17928
17929
17930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17931   unsigned int jresult ;
17932   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17933   Extents *arg2 = 0 ;
17934   bool result;
17935
17936   arg1 = (Dali::Property::Value *)jarg1;
17937   arg2 = (Extents *)jarg2;
17938   if (!arg2) {
17939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17940     return 0;
17941   }
17942   {
17943     try {
17944       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17945     } catch (std::out_of_range& e) {
17946       {
17947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17948       };
17949     } catch (std::exception& e) {
17950       {
17951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17952       };
17953     } catch (...) {
17954       {
17955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17956       };
17957     }
17958   }
17959   jresult = result;
17960   return jresult;
17961 }
17962
17963
17964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17965   void * jresult ;
17966   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17967   Dali::Property::Array *result = 0 ;
17968
17969   arg1 = (Dali::Property::Value *)jarg1;
17970   {
17971     try {
17972       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17973     } catch (std::out_of_range& e) {
17974       {
17975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17976       };
17977     } catch (std::exception& e) {
17978       {
17979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17980       };
17981     } catch (Dali::DaliException e) {
17982       {
17983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17984       };
17985     } catch (...) {
17986       {
17987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17988       };
17989     }
17990   }
17991
17992   jresult = (void *)result;
17993   return jresult;
17994 }
17995
17996
17997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17998   void * jresult ;
17999   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18000   Dali::Property::Map *result = 0 ;
18001
18002   arg1 = (Dali::Property::Value *)jarg1;
18003   {
18004     try {
18005       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18006     } catch (std::out_of_range& e) {
18007       {
18008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18009       };
18010     } catch (std::exception& e) {
18011       {
18012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18013       };
18014     } catch (Dali::DaliException e) {
18015       {
18016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18017       };
18018     } catch (...) {
18019       {
18020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18021       };
18022     }
18023   }
18024
18025   jresult = (void *)result;
18026   return jresult;
18027 }
18028
18029
18030 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18031   char * jresult ;
18032   Dali::Property::Type arg1 ;
18033   char *result = 0 ;
18034
18035   arg1 = (Dali::Property::Type)jarg1;
18036   {
18037     try {
18038       result = (char *)Dali::PropertyTypes::GetName(arg1);
18039     } catch (std::out_of_range& e) {
18040       {
18041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18042       };
18043     } catch (std::exception& e) {
18044       {
18045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18046       };
18047     } catch (Dali::DaliException e) {
18048       {
18049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18050       };
18051     } catch (...) {
18052       {
18053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18054       };
18055     }
18056   }
18057
18058   jresult = SWIG_csharp_string_callback((const char *)result);
18059   return jresult;
18060 }
18061
18062
18063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18064   unsigned int jresult ;
18065   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18066   std::string *arg2 = 0 ;
18067   Dali::Property::Map *arg3 = 0 ;
18068   bool result;
18069
18070   arg1 = (Dali::BaseObject *)jarg1;
18071   if (!jarg2) {
18072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18073     return 0;
18074   }
18075   std::string arg2_str(jarg2);
18076   arg2 = &arg2_str;
18077   arg3 = (Dali::Property::Map *)jarg3;
18078   if (!arg3) {
18079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18080     return 0;
18081   }
18082   {
18083     try {
18084       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18085     } catch (std::out_of_range& e) {
18086       {
18087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18088       };
18089     } catch (std::exception& e) {
18090       {
18091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18092       };
18093     } catch (Dali::DaliException e) {
18094       {
18095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18096       };
18097     } catch (...) {
18098       {
18099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18100       };
18101     }
18102   }
18103
18104   jresult = result;
18105
18106   //argout typemap for const std::string&
18107
18108   return jresult;
18109 }
18110
18111
18112 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18113   char * jresult ;
18114   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18115   std::string *result = 0 ;
18116
18117   arg1 = (Dali::BaseObject *)jarg1;
18118   {
18119     try {
18120       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18121     } catch (std::out_of_range& e) {
18122       {
18123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18124       };
18125     } catch (std::exception& e) {
18126       {
18127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18128       };
18129     } catch (Dali::DaliException e) {
18130       {
18131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18132       };
18133     } catch (...) {
18134       {
18135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18136       };
18137     }
18138   }
18139
18140   jresult = SWIG_csharp_string_callback(result->c_str());
18141   return jresult;
18142 }
18143
18144
18145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18146   unsigned int jresult ;
18147   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18148   Dali::TypeInfo *arg2 = 0 ;
18149   bool result;
18150
18151   arg1 = (Dali::BaseObject *)jarg1;
18152   arg2 = (Dali::TypeInfo *)jarg2;
18153   if (!arg2) {
18154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18155     return 0;
18156   }
18157   {
18158     try {
18159       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18160     } catch (std::out_of_range& e) {
18161       {
18162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18163       };
18164     } catch (std::exception& e) {
18165       {
18166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18167       };
18168     } catch (Dali::DaliException e) {
18169       {
18170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18171       };
18172     } catch (...) {
18173       {
18174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18175       };
18176     }
18177   }
18178
18179   jresult = result;
18180   return jresult;
18181 }
18182
18183
18184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18185   unsigned int jresult ;
18186   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18187   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18188   std::string *arg3 = 0 ;
18189   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18190   bool result;
18191
18192   arg1 = (Dali::BaseObject *)jarg1;
18193   arg2 = (ConnectionTrackerInterface *)jarg2;
18194   if (!jarg3) {
18195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18196     return 0;
18197   }
18198   std::string arg3_str(jarg3);
18199   arg3 = &arg3_str;
18200   arg4 = (FunctorDelegate *)jarg4;
18201   {
18202     try {
18203       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18204     } catch (std::out_of_range& e) {
18205       {
18206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18207       };
18208     } catch (std::exception& e) {
18209       {
18210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18211       };
18212     } catch (Dali::DaliException e) {
18213       {
18214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18215       };
18216     } catch (...) {
18217       {
18218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18219       };
18220     }
18221   }
18222
18223   jresult = result;
18224
18225   //argout typemap for const std::string&
18226
18227   return jresult;
18228 }
18229
18230
18231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18232   void * jresult ;
18233   Dali::BaseHandle *arg1 = 0 ;
18234   Dali::BaseObject *result = 0 ;
18235
18236   arg1 = (Dali::BaseHandle *)jarg1;
18237   if (!arg1) {
18238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18239     return 0;
18240   }
18241   {
18242     try {
18243       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18244     } catch (std::out_of_range& e) {
18245       {
18246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18247       };
18248     } catch (std::exception& e) {
18249       {
18250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18251       };
18252     } catch (Dali::DaliException e) {
18253       {
18254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18255       };
18256     } catch (...) {
18257       {
18258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18259       };
18260     }
18261   }
18262
18263   jresult = (void *)result;
18264   return jresult;
18265 }
18266
18267
18268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18269   void * jresult ;
18270   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18271   Dali::BaseHandle *result = 0 ;
18272
18273   arg1 = (Dali::BaseObject *)jarg1;
18274   {
18275     try {
18276       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18277     } catch (std::out_of_range& e) {
18278       {
18279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18280       };
18281     } catch (std::exception& e) {
18282       {
18283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18284       };
18285     } catch (Dali::DaliException e) {
18286       {
18287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18288       };
18289     } catch (...) {
18290       {
18291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18292       };
18293     }
18294   }
18295
18296   jresult = (void *)result;
18297   return jresult;
18298 }
18299
18300
18301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18302   void * jresult ;
18303   Dali::BaseHandle *result = 0 ;
18304
18305   {
18306     try {
18307       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18308     } catch (std::out_of_range& e) {
18309       {
18310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18311       };
18312     } catch (std::exception& e) {
18313       {
18314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18315       };
18316     } catch (Dali::DaliException e) {
18317       {
18318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18319       };
18320     } catch (...) {
18321       {
18322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18323       };
18324     }
18325   }
18326
18327   jresult = (void *)result;
18328   return jresult;
18329 }
18330
18331
18332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18333   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18334
18335   arg1 = (Dali::BaseHandle *)jarg1;
18336   {
18337     try {
18338       delete arg1;
18339     } catch (std::out_of_range& e) {
18340       {
18341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18342       };
18343     } catch (std::exception& e) {
18344       {
18345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18346       };
18347     } catch (Dali::DaliException e) {
18348       {
18349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18350       };
18351     } catch (...) {
18352       {
18353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18354       };
18355     }
18356   }
18357
18358 }
18359
18360
18361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18362   void * jresult ;
18363   Dali::BaseHandle *arg1 = 0 ;
18364   Dali::BaseHandle *result = 0 ;
18365
18366   arg1 = (Dali::BaseHandle *)jarg1;
18367   if (!arg1) {
18368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18369     return 0;
18370   }
18371   {
18372     try {
18373       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18374     } catch (std::out_of_range& e) {
18375       {
18376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18377       };
18378     } catch (std::exception& e) {
18379       {
18380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18381       };
18382     } catch (Dali::DaliException e) {
18383       {
18384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18385       };
18386     } catch (...) {
18387       {
18388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18389       };
18390     }
18391   }
18392
18393   jresult = (void *)result;
18394   return jresult;
18395 }
18396
18397
18398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18399   void * jresult ;
18400   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18401   Dali::BaseHandle *arg2 = 0 ;
18402   Dali::BaseHandle *result = 0 ;
18403
18404   arg1 = (Dali::BaseHandle *)jarg1;
18405   arg2 = (Dali::BaseHandle *)jarg2;
18406   if (!arg2) {
18407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18408     return 0;
18409   }
18410   {
18411     try {
18412       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18413     } catch (std::out_of_range& e) {
18414       {
18415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18416       };
18417     } catch (std::exception& e) {
18418       {
18419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18420       };
18421     } catch (Dali::DaliException e) {
18422       {
18423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18424       };
18425     } catch (...) {
18426       {
18427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18428       };
18429     }
18430   }
18431
18432   jresult = (void *)result;
18433   return jresult;
18434 }
18435
18436
18437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18438   unsigned int jresult ;
18439   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18440   std::string *arg2 = 0 ;
18441   Dali::Property::Map *arg3 = 0 ;
18442   bool result;
18443
18444   arg1 = (Dali::BaseHandle *)jarg1;
18445   if (!jarg2) {
18446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18447     return 0;
18448   }
18449   std::string arg2_str(jarg2);
18450   arg2 = &arg2_str;
18451   arg3 = (Dali::Property::Map *)jarg3;
18452   if (!arg3) {
18453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18454     return 0;
18455   }
18456   {
18457     try {
18458       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18459     } catch (std::out_of_range& e) {
18460       {
18461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18462       };
18463     } catch (std::exception& e) {
18464       {
18465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18466       };
18467     } catch (Dali::DaliException e) {
18468       {
18469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18470       };
18471     } catch (...) {
18472       {
18473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18474       };
18475     }
18476   }
18477
18478   jresult = result;
18479
18480   //argout typemap for const std::string&
18481
18482   return jresult;
18483 }
18484
18485
18486 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18487   char * jresult ;
18488   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18489   std::string *result = 0 ;
18490
18491   arg1 = (Dali::BaseHandle *)jarg1;
18492   {
18493     try {
18494       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18495     } catch (std::out_of_range& e) {
18496       {
18497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18498       };
18499     } catch (std::exception& e) {
18500       {
18501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18502       };
18503     } catch (Dali::DaliException e) {
18504       {
18505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18506       };
18507     } catch (...) {
18508       {
18509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18510       };
18511     }
18512   }
18513
18514   jresult = SWIG_csharp_string_callback(result->c_str());
18515   return jresult;
18516 }
18517
18518
18519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18520   unsigned int jresult ;
18521   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18522   Dali::TypeInfo *arg2 = 0 ;
18523   bool result;
18524
18525   arg1 = (Dali::BaseHandle *)jarg1;
18526   arg2 = (Dali::TypeInfo *)jarg2;
18527   if (!arg2) {
18528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18529     return 0;
18530   }
18531   {
18532     try {
18533       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18534     } catch (std::out_of_range& e) {
18535       {
18536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18537       };
18538     } catch (std::exception& e) {
18539       {
18540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18541       };
18542     } catch (Dali::DaliException e) {
18543       {
18544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18545       };
18546     } catch (...) {
18547       {
18548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18549       };
18550     }
18551   }
18552
18553   jresult = result;
18554   return jresult;
18555 }
18556
18557
18558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18559   void * jresult ;
18560   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18561   Dali::BaseObject *result = 0 ;
18562
18563   arg1 = (Dali::BaseHandle *)jarg1;
18564   {
18565     try {
18566       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18567     } catch (std::out_of_range& e) {
18568       {
18569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18570       };
18571     } catch (std::exception& e) {
18572       {
18573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18574       };
18575     } catch (Dali::DaliException e) {
18576       {
18577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18578       };
18579     } catch (...) {
18580       {
18581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18582       };
18583     }
18584   }
18585
18586   jresult = (void *)result;
18587   return jresult;
18588 }
18589
18590
18591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18592   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18593
18594   arg1 = (Dali::BaseHandle *)jarg1;
18595   {
18596     try {
18597       (arg1)->Reset();
18598     } catch (std::out_of_range& e) {
18599       {
18600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18601       };
18602     } catch (std::exception& e) {
18603       {
18604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18605       };
18606     } catch (Dali::DaliException e) {
18607       {
18608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18609       };
18610     } catch (...) {
18611       {
18612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18613       };
18614     }
18615   }
18616
18617 }
18618
18619
18620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18621   unsigned int jresult ;
18622   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18623   Dali::BaseHandle *arg2 = 0 ;
18624   bool result;
18625
18626   arg1 = (Dali::BaseHandle *)jarg1;
18627   arg2 = (Dali::BaseHandle *)jarg2;
18628   if (!arg2) {
18629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18630     return 0;
18631   }
18632   {
18633     try {
18634       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18635     } catch (std::out_of_range& e) {
18636       {
18637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18638       };
18639     } catch (std::exception& e) {
18640       {
18641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18642       };
18643     } catch (Dali::DaliException e) {
18644       {
18645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18646       };
18647     } catch (...) {
18648       {
18649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18650       };
18651     }
18652   }
18653
18654   jresult = result;
18655   return jresult;
18656 }
18657
18658
18659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18660   unsigned int jresult ;
18661   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18662   Dali::BaseHandle *arg2 = 0 ;
18663   bool result;
18664
18665   arg1 = (Dali::BaseHandle *)jarg1;
18666   arg2 = (Dali::BaseHandle *)jarg2;
18667   if (!arg2) {
18668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18669     return 0;
18670   }
18671   {
18672     try {
18673       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18674     } catch (std::out_of_range& e) {
18675       {
18676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18677       };
18678     } catch (std::exception& e) {
18679       {
18680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18681       };
18682     } catch (Dali::DaliException e) {
18683       {
18684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18685       };
18686     } catch (...) {
18687       {
18688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18689       };
18690     }
18691   }
18692
18693   jresult = result;
18694   return jresult;
18695 }
18696
18697
18698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18699   void * jresult ;
18700   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18701   Dali::RefObject *result = 0 ;
18702
18703   arg1 = (Dali::BaseHandle *)jarg1;
18704   {
18705     try {
18706       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18707     } catch (std::out_of_range& e) {
18708       {
18709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18710       };
18711     } catch (std::exception& e) {
18712       {
18713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18714       };
18715     } catch (Dali::DaliException e) {
18716       {
18717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18718       };
18719     } catch (...) {
18720       {
18721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18722       };
18723     }
18724   }
18725
18726   jresult = (void *)result;
18727   return jresult;
18728 }
18729
18730
18731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18732   unsigned int jresult ;
18733   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18734   bool result;
18735
18736   arg1 = (Dali::BaseHandle *)jarg1;
18737   {
18738     try {
18739       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18740     } catch (std::out_of_range& e) {
18741       {
18742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18743       };
18744     } catch (std::exception& e) {
18745       {
18746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18747       };
18748     } catch (Dali::DaliException e) {
18749       {
18750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18751       };
18752     } catch (...) {
18753       {
18754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18755       };
18756     }
18757   }
18758
18759   jresult = result;
18760   return jresult;
18761 }
18762
18763
18764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18765   unsigned int jresult ;
18766   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18767   Dali::BaseHandle *arg2 = 0 ;
18768   bool result;
18769
18770   arg1 = (Dali::BaseHandle *)jarg1;
18771   arg2 = (Dali::BaseHandle *)jarg2;
18772   if (!arg2) {
18773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18774     return 0;
18775   }
18776   {
18777     try {
18778       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18779     } catch (std::out_of_range& e) {
18780       {
18781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18782       };
18783     } catch (std::exception& e) {
18784       {
18785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18786       };
18787     } catch (Dali::DaliException e) {
18788       {
18789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18790       };
18791     } catch (...) {
18792       {
18793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18794       };
18795     }
18796   }
18797
18798   jresult = result;
18799   return jresult;
18800 }
18801
18802
18803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18804   unsigned int jresult ;
18805   Dali::BaseHandle *arg1 = 0 ;
18806   Dali::BaseHandle *arg2 = 0 ;
18807   bool result;
18808
18809   arg1 = (Dali::BaseHandle *)jarg1;
18810   if (!arg1) {
18811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18812     return 0;
18813   }
18814   arg2 = (Dali::BaseHandle *)jarg2;
18815   if (!arg2) {
18816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18817     return 0;
18818   }
18819   {
18820     try {
18821       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18822     } catch (std::out_of_range& e) {
18823       {
18824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18825       };
18826     } catch (std::exception& e) {
18827       {
18828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18829       };
18830     } catch (Dali::DaliException e) {
18831       {
18832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18833       };
18834     } catch (...) {
18835       {
18836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18837       };
18838     }
18839   }
18840
18841   jresult = result;
18842   return jresult;
18843 }
18844
18845
18846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18847   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18848
18849   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18850   {
18851     try {
18852       delete arg1;
18853     } catch (std::out_of_range& e) {
18854       {
18855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18856       };
18857     } catch (std::exception& e) {
18858       {
18859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18860       };
18861     } catch (Dali::DaliException e) {
18862       {
18863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18864       };
18865     } catch (...) {
18866       {
18867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18868       };
18869     }
18870   }
18871
18872 }
18873
18874
18875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18876   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18877   SlotObserver *arg2 = (SlotObserver *) 0 ;
18878   CallbackBase *arg3 = (CallbackBase *) 0 ;
18879
18880   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18881   arg2 = (SlotObserver *)jarg2;
18882   arg3 = (CallbackBase *)jarg3;
18883   {
18884     try {
18885       (arg1)->SignalConnected(arg2,arg3);
18886     } catch (std::out_of_range& e) {
18887       {
18888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18889       };
18890     } catch (std::exception& e) {
18891       {
18892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18893       };
18894     } catch (Dali::DaliException e) {
18895       {
18896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18897       };
18898     } catch (...) {
18899       {
18900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18901       };
18902     }
18903   }
18904
18905 }
18906
18907
18908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18909   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18910
18911   arg1 = (Dali::SignalObserver *)jarg1;
18912   {
18913     try {
18914       delete arg1;
18915     } catch (std::out_of_range& e) {
18916       {
18917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18918       };
18919     } catch (std::exception& e) {
18920       {
18921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18922       };
18923     } catch (Dali::DaliException e) {
18924       {
18925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18926       };
18927     } catch (...) {
18928       {
18929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18930       };
18931     }
18932   }
18933
18934 }
18935
18936
18937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18938   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18939   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18940   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18941
18942   arg1 = (Dali::SignalObserver *)jarg1;
18943   arg2 = (Dali::SlotObserver *)jarg2;
18944   arg3 = (Dali::CallbackBase *)jarg3;
18945   {
18946     try {
18947       (arg1)->SignalDisconnected(arg2,arg3);
18948     } catch (std::out_of_range& e) {
18949       {
18950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18951       };
18952     } catch (std::exception& e) {
18953       {
18954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18955       };
18956     } catch (Dali::DaliException e) {
18957       {
18958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18959       };
18960     } catch (...) {
18961       {
18962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18963       };
18964     }
18965   }
18966
18967 }
18968
18969
18970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18971   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18972
18973   arg1 = (Dali::SlotObserver *)jarg1;
18974   {
18975     try {
18976       delete arg1;
18977     } catch (std::out_of_range& e) {
18978       {
18979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18980       };
18981     } catch (std::exception& e) {
18982       {
18983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18984       };
18985     } catch (Dali::DaliException e) {
18986       {
18987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18988       };
18989     } catch (...) {
18990       {
18991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18992       };
18993     }
18994   }
18995
18996 }
18997
18998
18999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19000   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19001   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19002
19003   arg1 = (Dali::SlotObserver *)jarg1;
19004   arg2 = (Dali::CallbackBase *)jarg2;
19005   {
19006     try {
19007       (arg1)->SlotDisconnected(arg2);
19008     } catch (std::out_of_range& e) {
19009       {
19010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19011       };
19012     } catch (std::exception& e) {
19013       {
19014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19015       };
19016     } catch (Dali::DaliException e) {
19017       {
19018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19019       };
19020     } catch (...) {
19021       {
19022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19023       };
19024     }
19025   }
19026
19027 }
19028
19029
19030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19031   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19032
19033   arg1 = (Dali::ConnectionTracker *)jarg1;
19034   {
19035     try {
19036       delete arg1;
19037     } catch (std::out_of_range& e) {
19038       {
19039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19040       };
19041     } catch (std::exception& e) {
19042       {
19043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19044       };
19045     } catch (Dali::DaliException e) {
19046       {
19047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19048       };
19049     } catch (...) {
19050       {
19051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19052       };
19053     }
19054   }
19055
19056 }
19057
19058
19059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19060   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19061
19062   arg1 = (Dali::ConnectionTracker *)jarg1;
19063   {
19064     try {
19065       (arg1)->DisconnectAll();
19066     } catch (std::out_of_range& e) {
19067       {
19068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19069       };
19070     } catch (std::exception& e) {
19071       {
19072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19073       };
19074     } catch (Dali::DaliException e) {
19075       {
19076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19077       };
19078     } catch (...) {
19079       {
19080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19081       };
19082     }
19083   }
19084
19085 }
19086
19087
19088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19089   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19090   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19091   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19092
19093   arg1 = (Dali::ConnectionTracker *)jarg1;
19094   arg2 = (Dali::SlotObserver *)jarg2;
19095   arg3 = (Dali::CallbackBase *)jarg3;
19096   {
19097     try {
19098       (arg1)->SignalConnected(arg2,arg3);
19099     } catch (std::out_of_range& e) {
19100       {
19101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19102       };
19103     } catch (std::exception& e) {
19104       {
19105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19106       };
19107     } catch (Dali::DaliException e) {
19108       {
19109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19110       };
19111     } catch (...) {
19112       {
19113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19114       };
19115     }
19116   }
19117
19118 }
19119
19120
19121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19122   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19123   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19124   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19125
19126   arg1 = (Dali::ConnectionTracker *)jarg1;
19127   arg2 = (Dali::SlotObserver *)jarg2;
19128   arg3 = (Dali::CallbackBase *)jarg3;
19129   {
19130     try {
19131       (arg1)->SignalDisconnected(arg2,arg3);
19132     } catch (std::out_of_range& e) {
19133       {
19134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19135       };
19136     } catch (std::exception& e) {
19137       {
19138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19139       };
19140     } catch (Dali::DaliException e) {
19141       {
19142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19143       };
19144     } catch (...) {
19145       {
19146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19147       };
19148     }
19149   }
19150
19151 }
19152
19153
19154 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19155   unsigned long jresult ;
19156   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19157   std::size_t result;
19158
19159   arg1 = (Dali::ConnectionTracker *)jarg1;
19160   {
19161     try {
19162       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19163     } catch (std::out_of_range& e) {
19164       {
19165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19166       };
19167     } catch (std::exception& e) {
19168       {
19169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19170       };
19171     } catch (Dali::DaliException e) {
19172       {
19173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19174       };
19175     } catch (...) {
19176       {
19177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19178       };
19179     }
19180   }
19181
19182   jresult = (unsigned long)result;
19183   return jresult;
19184 }
19185
19186
19187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19188   void * jresult ;
19189   Dali::ObjectRegistry *result = 0 ;
19190
19191   {
19192     try {
19193       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19194     } catch (std::out_of_range& e) {
19195       {
19196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19197       };
19198     } catch (std::exception& e) {
19199       {
19200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19201       };
19202     } catch (Dali::DaliException e) {
19203       {
19204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19205       };
19206     } catch (...) {
19207       {
19208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19209       };
19210     }
19211   }
19212
19213   jresult = (void *)result;
19214   return jresult;
19215 }
19216
19217
19218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19219   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19220
19221   arg1 = (Dali::ObjectRegistry *)jarg1;
19222   {
19223     try {
19224       delete arg1;
19225     } catch (std::out_of_range& e) {
19226       {
19227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19228       };
19229     } catch (std::exception& e) {
19230       {
19231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19232       };
19233     } catch (Dali::DaliException e) {
19234       {
19235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19236       };
19237     } catch (...) {
19238       {
19239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19240       };
19241     }
19242   }
19243
19244 }
19245
19246
19247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19248   void * jresult ;
19249   Dali::ObjectRegistry *arg1 = 0 ;
19250   Dali::ObjectRegistry *result = 0 ;
19251
19252   arg1 = (Dali::ObjectRegistry *)jarg1;
19253   if (!arg1) {
19254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19255     return 0;
19256   }
19257   {
19258     try {
19259       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19260     } catch (std::out_of_range& e) {
19261       {
19262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19263       };
19264     } catch (std::exception& e) {
19265       {
19266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19267       };
19268     } catch (Dali::DaliException e) {
19269       {
19270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19271       };
19272     } catch (...) {
19273       {
19274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19275       };
19276     }
19277   }
19278
19279   jresult = (void *)result;
19280   return jresult;
19281 }
19282
19283
19284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19285   void * jresult ;
19286   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19287   Dali::ObjectRegistry *arg2 = 0 ;
19288   Dali::ObjectRegistry *result = 0 ;
19289
19290   arg1 = (Dali::ObjectRegistry *)jarg1;
19291   arg2 = (Dali::ObjectRegistry *)jarg2;
19292   if (!arg2) {
19293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19294     return 0;
19295   }
19296   {
19297     try {
19298       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19299     } catch (std::out_of_range& e) {
19300       {
19301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19302       };
19303     } catch (std::exception& e) {
19304       {
19305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19306       };
19307     } catch (Dali::DaliException e) {
19308       {
19309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19310       };
19311     } catch (...) {
19312       {
19313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19314       };
19315     }
19316   }
19317
19318   jresult = (void *)result;
19319   return jresult;
19320 }
19321
19322
19323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19324   void * jresult ;
19325   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19326   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19327
19328   arg1 = (Dali::ObjectRegistry *)jarg1;
19329   {
19330     try {
19331       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19332     } catch (std::out_of_range& e) {
19333       {
19334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19335       };
19336     } catch (std::exception& e) {
19337       {
19338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19339       };
19340     } catch (Dali::DaliException e) {
19341       {
19342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19343       };
19344     } catch (...) {
19345       {
19346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19347       };
19348     }
19349   }
19350
19351   jresult = (void *)result;
19352   return jresult;
19353 }
19354
19355
19356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19357   void * jresult ;
19358   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19359   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19360
19361   arg1 = (Dali::ObjectRegistry *)jarg1;
19362   {
19363     try {
19364       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19365     } catch (std::out_of_range& e) {
19366       {
19367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19368       };
19369     } catch (std::exception& e) {
19370       {
19371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19372       };
19373     } catch (Dali::DaliException e) {
19374       {
19375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19376       };
19377     } catch (...) {
19378       {
19379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19380       };
19381     }
19382   }
19383
19384   jresult = (void *)result;
19385   return jresult;
19386 }
19387
19388
19389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19390   void * jresult ;
19391   Dali::PropertyCondition *result = 0 ;
19392
19393   {
19394     try {
19395       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19396     } catch (std::out_of_range& e) {
19397       {
19398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19399       };
19400     } catch (std::exception& e) {
19401       {
19402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19403       };
19404     } catch (Dali::DaliException e) {
19405       {
19406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19407       };
19408     } catch (...) {
19409       {
19410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19411       };
19412     }
19413   }
19414
19415   jresult = (void *)result;
19416   return jresult;
19417 }
19418
19419
19420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19421   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19422
19423   arg1 = (Dali::PropertyCondition *)jarg1;
19424   {
19425     try {
19426       delete arg1;
19427     } catch (std::out_of_range& e) {
19428       {
19429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19430       };
19431     } catch (std::exception& e) {
19432       {
19433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19434       };
19435     } catch (Dali::DaliException e) {
19436       {
19437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19438       };
19439     } catch (...) {
19440       {
19441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19442       };
19443     }
19444   }
19445
19446 }
19447
19448
19449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19450   void * jresult ;
19451   Dali::PropertyCondition *arg1 = 0 ;
19452   Dali::PropertyCondition *result = 0 ;
19453
19454   arg1 = (Dali::PropertyCondition *)jarg1;
19455   if (!arg1) {
19456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19457     return 0;
19458   }
19459   {
19460     try {
19461       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19462     } catch (std::out_of_range& e) {
19463       {
19464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19465       };
19466     } catch (std::exception& e) {
19467       {
19468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19469       };
19470     } catch (Dali::DaliException e) {
19471       {
19472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19473       };
19474     } catch (...) {
19475       {
19476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19477       };
19478     }
19479   }
19480
19481   jresult = (void *)result;
19482   return jresult;
19483 }
19484
19485
19486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19487   void * jresult ;
19488   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19489   Dali::PropertyCondition *arg2 = 0 ;
19490   Dali::PropertyCondition *result = 0 ;
19491
19492   arg1 = (Dali::PropertyCondition *)jarg1;
19493   arg2 = (Dali::PropertyCondition *)jarg2;
19494   if (!arg2) {
19495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19496     return 0;
19497   }
19498   {
19499     try {
19500       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19501     } catch (std::out_of_range& e) {
19502       {
19503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19504       };
19505     } catch (std::exception& e) {
19506       {
19507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19508       };
19509     } catch (Dali::DaliException e) {
19510       {
19511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19512       };
19513     } catch (...) {
19514       {
19515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19516       };
19517     }
19518   }
19519
19520   jresult = (void *)result;
19521   return jresult;
19522 }
19523
19524
19525 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19526   unsigned long jresult ;
19527   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19528   std::size_t result;
19529
19530   arg1 = (Dali::PropertyCondition *)jarg1;
19531   {
19532     try {
19533       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19534     } catch (std::out_of_range& e) {
19535       {
19536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19537       };
19538     } catch (std::exception& e) {
19539       {
19540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19541       };
19542     } catch (...) {
19543       {
19544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19545       };
19546     }
19547   }
19548   jresult = (unsigned long)result;
19549   return jresult;
19550 }
19551
19552
19553 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19554   float jresult ;
19555   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19556   std::size_t arg2 ;
19557   float result;
19558
19559   arg1 = (Dali::PropertyCondition *)jarg1;
19560   arg2 = (std::size_t)jarg2;
19561   {
19562     try {
19563       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19564     } catch (std::out_of_range& e) {
19565       {
19566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19567       };
19568     } catch (std::exception& e) {
19569       {
19570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19571       };
19572     } catch (...) {
19573       {
19574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19575       };
19576     }
19577   }
19578   jresult = result;
19579   return jresult;
19580 }
19581
19582
19583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19584   void * jresult ;
19585   float arg1 ;
19586   Dali::PropertyCondition result;
19587
19588   arg1 = (float)jarg1;
19589   {
19590     try {
19591       result = Dali::LessThanCondition(arg1);
19592     } catch (std::out_of_range& e) {
19593       {
19594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19595       };
19596     } catch (std::exception& e) {
19597       {
19598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19599       };
19600     } catch (Dali::DaliException e) {
19601       {
19602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19603       };
19604     } catch (...) {
19605       {
19606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19607       };
19608     }
19609   }
19610
19611   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19612   return jresult;
19613 }
19614
19615
19616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19617   void * jresult ;
19618   float arg1 ;
19619   Dali::PropertyCondition result;
19620
19621   arg1 = (float)jarg1;
19622   {
19623     try {
19624       result = Dali::GreaterThanCondition(arg1);
19625     } catch (std::out_of_range& e) {
19626       {
19627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19628       };
19629     } catch (std::exception& e) {
19630       {
19631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19632       };
19633     } catch (Dali::DaliException e) {
19634       {
19635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19636       };
19637     } catch (...) {
19638       {
19639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19640       };
19641     }
19642   }
19643
19644   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19645   return jresult;
19646 }
19647
19648
19649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19650   void * jresult ;
19651   float arg1 ;
19652   float arg2 ;
19653   Dali::PropertyCondition result;
19654
19655   arg1 = (float)jarg1;
19656   arg2 = (float)jarg2;
19657   {
19658     try {
19659       result = Dali::InsideCondition(arg1,arg2);
19660     } catch (std::out_of_range& e) {
19661       {
19662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19663       };
19664     } catch (std::exception& e) {
19665       {
19666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19667       };
19668     } catch (Dali::DaliException e) {
19669       {
19670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19671       };
19672     } catch (...) {
19673       {
19674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19675       };
19676     }
19677   }
19678
19679   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19680   return jresult;
19681 }
19682
19683
19684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19685   void * jresult ;
19686   float arg1 ;
19687   float arg2 ;
19688   Dali::PropertyCondition result;
19689
19690   arg1 = (float)jarg1;
19691   arg2 = (float)jarg2;
19692   {
19693     try {
19694       result = Dali::OutsideCondition(arg1,arg2);
19695     } catch (std::out_of_range& e) {
19696       {
19697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19698       };
19699     } catch (std::exception& e) {
19700       {
19701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19702       };
19703     } catch (Dali::DaliException e) {
19704       {
19705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19706       };
19707     } catch (...) {
19708       {
19709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19710       };
19711     }
19712   }
19713
19714   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19715   return jresult;
19716 }
19717
19718
19719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19720   void * jresult ;
19721   float arg1 ;
19722   float arg2 ;
19723   Dali::PropertyCondition result;
19724
19725   arg1 = (float)jarg1;
19726   arg2 = (float)jarg2;
19727   {
19728     try {
19729       result = Dali::StepCondition(arg1,arg2);
19730     } catch (std::out_of_range& e) {
19731       {
19732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19733       };
19734     } catch (std::exception& e) {
19735       {
19736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19737       };
19738     } catch (Dali::DaliException e) {
19739       {
19740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19741       };
19742     } catch (...) {
19743       {
19744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19745       };
19746     }
19747   }
19748
19749   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19750   return jresult;
19751 }
19752
19753
19754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19755   void * jresult ;
19756   float arg1 ;
19757   Dali::PropertyCondition result;
19758
19759   arg1 = (float)jarg1;
19760   {
19761     try {
19762       result = Dali::StepCondition(arg1);
19763     } catch (std::out_of_range& e) {
19764       {
19765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19766       };
19767     } catch (std::exception& e) {
19768       {
19769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19770       };
19771     } catch (Dali::DaliException e) {
19772       {
19773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19774       };
19775     } catch (...) {
19776       {
19777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19778       };
19779     }
19780   }
19781
19782   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19783   return jresult;
19784 }
19785
19786
19787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19788   void * jresult ;
19789   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19790   Dali::PropertyCondition result;
19791
19792   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19793   if (!arg1) {
19794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19795     return 0;
19796   }
19797   {
19798     try {
19799       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19800     } catch (std::out_of_range& e) {
19801       {
19802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19803       };
19804     } catch (std::exception& e) {
19805       {
19806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19807       };
19808     } catch (Dali::DaliException e) {
19809       {
19810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19811       };
19812     } catch (...) {
19813       {
19814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19815       };
19816     }
19817   }
19818
19819   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19820   return jresult;
19821 }
19822
19823
19824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19825   void * jresult ;
19826   Dali::PropertyNotification *result = 0 ;
19827
19828   {
19829     try {
19830       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19831     } catch (std::out_of_range& e) {
19832       {
19833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19834       };
19835     } catch (std::exception& e) {
19836       {
19837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19838       };
19839     } catch (Dali::DaliException e) {
19840       {
19841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19842       };
19843     } catch (...) {
19844       {
19845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19846       };
19847     }
19848   }
19849
19850   jresult = (void *)result;
19851   return jresult;
19852 }
19853
19854
19855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19856   void * jresult ;
19857   Dali::BaseHandle arg1 ;
19858   Dali::BaseHandle *argp1 ;
19859   Dali::PropertyNotification result;
19860
19861   argp1 = (Dali::BaseHandle *)jarg1;
19862   if (!argp1) {
19863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19864     return 0;
19865   }
19866   arg1 = *argp1;
19867   {
19868     try {
19869       result = Dali::PropertyNotification::DownCast(arg1);
19870     } catch (std::out_of_range& e) {
19871       {
19872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19873       };
19874     } catch (std::exception& e) {
19875       {
19876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19877       };
19878     } catch (Dali::DaliException e) {
19879       {
19880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19881       };
19882     } catch (...) {
19883       {
19884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19885       };
19886     }
19887   }
19888
19889   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19890   return jresult;
19891 }
19892
19893
19894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19895   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19896
19897   arg1 = (Dali::PropertyNotification *)jarg1;
19898   {
19899     try {
19900       delete arg1;
19901     } catch (std::out_of_range& e) {
19902       {
19903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19904       };
19905     } catch (std::exception& e) {
19906       {
19907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19908       };
19909     } catch (Dali::DaliException e) {
19910       {
19911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19912       };
19913     } catch (...) {
19914       {
19915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19916       };
19917     }
19918   }
19919
19920 }
19921
19922
19923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19924   void * jresult ;
19925   Dali::PropertyNotification *arg1 = 0 ;
19926   Dali::PropertyNotification *result = 0 ;
19927
19928   arg1 = (Dali::PropertyNotification *)jarg1;
19929   if (!arg1) {
19930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19931     return 0;
19932   }
19933   {
19934     try {
19935       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19936     } catch (std::out_of_range& e) {
19937       {
19938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19939       };
19940     } catch (std::exception& e) {
19941       {
19942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19943       };
19944     } catch (Dali::DaliException e) {
19945       {
19946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19947       };
19948     } catch (...) {
19949       {
19950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19951       };
19952     }
19953   }
19954
19955   jresult = (void *)result;
19956   return jresult;
19957 }
19958
19959
19960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19961   void * jresult ;
19962   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19963   Dali::PropertyNotification *arg2 = 0 ;
19964   Dali::PropertyNotification *result = 0 ;
19965
19966   arg1 = (Dali::PropertyNotification *)jarg1;
19967   arg2 = (Dali::PropertyNotification *)jarg2;
19968   if (!arg2) {
19969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19970     return 0;
19971   }
19972   {
19973     try {
19974       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19975     } catch (std::out_of_range& e) {
19976       {
19977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19978       };
19979     } catch (std::exception& e) {
19980       {
19981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19982       };
19983     } catch (Dali::DaliException e) {
19984       {
19985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19986       };
19987     } catch (...) {
19988       {
19989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19990       };
19991     }
19992   }
19993
19994   jresult = (void *)result;
19995   return jresult;
19996 }
19997
19998
19999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20000   void * jresult ;
20001   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20002   Dali::PropertyCondition result;
20003
20004   arg1 = (Dali::PropertyNotification *)jarg1;
20005   {
20006     try {
20007       result = (arg1)->GetCondition();
20008     } catch (std::out_of_range& e) {
20009       {
20010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20011       };
20012     } catch (std::exception& e) {
20013       {
20014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20015       };
20016     } catch (Dali::DaliException e) {
20017       {
20018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20019       };
20020     } catch (...) {
20021       {
20022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20023       };
20024     }
20025   }
20026
20027   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20028   return jresult;
20029 }
20030
20031
20032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20033   void * jresult ;
20034   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20035   Dali::Handle result;
20036
20037   arg1 = (Dali::PropertyNotification *)jarg1;
20038   {
20039     try {
20040       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20041     } catch (std::out_of_range& e) {
20042       {
20043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20044       };
20045     } catch (std::exception& e) {
20046       {
20047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20048       };
20049     } catch (Dali::DaliException e) {
20050       {
20051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20052       };
20053     } catch (...) {
20054       {
20055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20056       };
20057     }
20058   }
20059
20060   jresult = new Dali::Handle((const Dali::Handle &)result);
20061   return jresult;
20062 }
20063
20064
20065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20066   int jresult ;
20067   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20068   Dali::Property::Index result;
20069
20070   arg1 = (Dali::PropertyNotification *)jarg1;
20071   {
20072     try {
20073       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20074     } catch (std::out_of_range& e) {
20075       {
20076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20077       };
20078     } catch (std::exception& e) {
20079       {
20080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20081       };
20082     } catch (Dali::DaliException e) {
20083       {
20084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20085       };
20086     } catch (...) {
20087       {
20088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20089       };
20090     }
20091   }
20092
20093   jresult = result;
20094   return jresult;
20095 }
20096
20097
20098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20099   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20100   Dali::PropertyNotification::NotifyMode arg2 ;
20101
20102   arg1 = (Dali::PropertyNotification *)jarg1;
20103   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20104   {
20105     try {
20106       (arg1)->SetNotifyMode(arg2);
20107     } catch (std::out_of_range& e) {
20108       {
20109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20110       };
20111     } catch (std::exception& e) {
20112       {
20113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20114       };
20115     } catch (Dali::DaliException e) {
20116       {
20117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20118       };
20119     } catch (...) {
20120       {
20121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20122       };
20123     }
20124   }
20125
20126 }
20127
20128
20129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20130   int jresult ;
20131   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20132   Dali::PropertyNotification::NotifyMode result;
20133
20134   arg1 = (Dali::PropertyNotification *)jarg1;
20135   {
20136     try {
20137       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20138     } catch (std::out_of_range& e) {
20139       {
20140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20141       };
20142     } catch (std::exception& e) {
20143       {
20144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20145       };
20146     } catch (Dali::DaliException e) {
20147       {
20148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20149       };
20150     } catch (...) {
20151       {
20152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20153       };
20154     }
20155   }
20156
20157   jresult = (int)result;
20158   return jresult;
20159 }
20160
20161
20162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20163   unsigned int jresult ;
20164   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20165   bool result;
20166
20167   arg1 = (Dali::PropertyNotification *)jarg1;
20168   {
20169     try {
20170       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20171     } catch (std::out_of_range& e) {
20172       {
20173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20174       };
20175     } catch (std::exception& e) {
20176       {
20177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20178       };
20179     } catch (Dali::DaliException e) {
20180       {
20181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20182       };
20183     } catch (...) {
20184       {
20185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20186       };
20187     }
20188   }
20189
20190   jresult = result;
20191   return jresult;
20192 }
20193
20194
20195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20196   void * jresult ;
20197   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20198   Dali::PropertyNotifySignalType *result = 0 ;
20199
20200   arg1 = (Dali::PropertyNotification *)jarg1;
20201   {
20202     try {
20203       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20204     } catch (std::out_of_range& e) {
20205       {
20206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20207       };
20208     } catch (std::exception& e) {
20209       {
20210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20211       };
20212     } catch (Dali::DaliException e) {
20213       {
20214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20215       };
20216     } catch (...) {
20217       {
20218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20219       };
20220     }
20221   }
20222
20223   jresult = (void *)result;
20224   return jresult;
20225 }
20226
20227
20228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20229   void * jresult ;
20230   Dali::Handle *result = 0 ;
20231
20232   {
20233     try {
20234       result = (Dali::Handle *)new Dali::Handle();
20235     } catch (std::out_of_range& e) {
20236       {
20237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20238       };
20239     } catch (std::exception& e) {
20240       {
20241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20242       };
20243     } catch (Dali::DaliException e) {
20244       {
20245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20246       };
20247     } catch (...) {
20248       {
20249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20250       };
20251     }
20252   }
20253
20254   jresult = (void *)result;
20255   return jresult;
20256 }
20257
20258
20259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20260   void * jresult ;
20261   Dali::Handle result;
20262
20263   {
20264     try {
20265       result = Dali::Handle::New();
20266     } catch (std::out_of_range& e) {
20267       {
20268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20269       };
20270     } catch (std::exception& e) {
20271       {
20272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20273       };
20274     } catch (Dali::DaliException e) {
20275       {
20276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20277       };
20278     } catch (...) {
20279       {
20280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20281       };
20282     }
20283   }
20284
20285   jresult = new Dali::Handle((const Dali::Handle &)result);
20286   return jresult;
20287 }
20288
20289
20290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20291   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20292
20293   arg1 = (Dali::Handle *)jarg1;
20294   {
20295     try {
20296       delete arg1;
20297     } catch (std::out_of_range& e) {
20298       {
20299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20300       };
20301     } catch (std::exception& e) {
20302       {
20303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20304       };
20305     } catch (Dali::DaliException e) {
20306       {
20307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20308       };
20309     } catch (...) {
20310       {
20311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20312       };
20313     }
20314   }
20315
20316 }
20317
20318
20319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20320   void * jresult ;
20321   Dali::Handle *arg1 = 0 ;
20322   Dali::Handle *result = 0 ;
20323
20324   arg1 = (Dali::Handle *)jarg1;
20325   if (!arg1) {
20326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20327     return 0;
20328   }
20329   {
20330     try {
20331       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20332     } catch (std::out_of_range& e) {
20333       {
20334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20335       };
20336     } catch (std::exception& e) {
20337       {
20338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20339       };
20340     } catch (Dali::DaliException e) {
20341       {
20342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20343       };
20344     } catch (...) {
20345       {
20346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20347       };
20348     }
20349   }
20350
20351   jresult = (void *)result;
20352   return jresult;
20353 }
20354
20355
20356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20357   void * jresult ;
20358   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20359   Dali::Handle *arg2 = 0 ;
20360   Dali::Handle *result = 0 ;
20361
20362   arg1 = (Dali::Handle *)jarg1;
20363   arg2 = (Dali::Handle *)jarg2;
20364   if (!arg2) {
20365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20366     return 0;
20367   }
20368   {
20369     try {
20370       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20371     } catch (std::out_of_range& e) {
20372       {
20373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20374       };
20375     } catch (std::exception& e) {
20376       {
20377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20378       };
20379     } catch (Dali::DaliException e) {
20380       {
20381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20382       };
20383     } catch (...) {
20384       {
20385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20386       };
20387     }
20388   }
20389
20390   jresult = (void *)result;
20391   return jresult;
20392 }
20393
20394
20395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20396   void * jresult ;
20397   Dali::BaseHandle arg1 ;
20398   Dali::BaseHandle *argp1 ;
20399   Dali::Handle result;
20400
20401   argp1 = (Dali::BaseHandle *)jarg1;
20402   if (!argp1) {
20403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20404     return 0;
20405   }
20406   arg1 = *argp1;
20407   {
20408     try {
20409       result = Dali::Handle::DownCast(arg1);
20410     } catch (std::out_of_range& e) {
20411       {
20412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20413       };
20414     } catch (std::exception& e) {
20415       {
20416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20417       };
20418     } catch (Dali::DaliException e) {
20419       {
20420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20421       };
20422     } catch (...) {
20423       {
20424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20425       };
20426     }
20427   }
20428
20429   jresult = new Dali::Handle((const Dali::Handle &)result);
20430   return jresult;
20431 }
20432
20433
20434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20435   unsigned int jresult ;
20436   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20437   Dali::Handle::Capability arg2 ;
20438   bool result;
20439
20440   arg1 = (Dali::Handle *)jarg1;
20441   arg2 = (Dali::Handle::Capability)jarg2;
20442   {
20443     try {
20444       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20445     } catch (std::out_of_range& e) {
20446       {
20447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20448       };
20449     } catch (std::exception& e) {
20450       {
20451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20452       };
20453     } catch (Dali::DaliException e) {
20454       {
20455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20456       };
20457     } catch (...) {
20458       {
20459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20460       };
20461     }
20462   }
20463
20464   jresult = result;
20465   return jresult;
20466 }
20467
20468
20469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20470   unsigned int jresult ;
20471   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20472   unsigned int result;
20473
20474   arg1 = (Dali::Handle *)jarg1;
20475   {
20476     try {
20477       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20478     } catch (std::out_of_range& e) {
20479       {
20480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20481       };
20482     } catch (std::exception& e) {
20483       {
20484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20485       };
20486     } catch (Dali::DaliException e) {
20487       {
20488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20489       };
20490     } catch (...) {
20491       {
20492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20493       };
20494     }
20495   }
20496
20497   jresult = result;
20498   return jresult;
20499 }
20500
20501
20502 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20503   char * jresult ;
20504   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20505   Dali::Property::Index arg2 ;
20506   std::string result;
20507
20508   arg1 = (Dali::Handle *)jarg1;
20509   arg2 = (Dali::Property::Index)jarg2;
20510   {
20511     try {
20512       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20513     } catch (std::out_of_range& e) {
20514       {
20515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20516       };
20517     } catch (std::exception& e) {
20518       {
20519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20520       };
20521     } catch (Dali::DaliException e) {
20522       {
20523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20524       };
20525     } catch (...) {
20526       {
20527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20528       };
20529     }
20530   }
20531
20532   jresult = SWIG_csharp_string_callback((&result)->c_str());
20533   return jresult;
20534 }
20535
20536
20537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20538   int jresult ;
20539   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20540   std::string *arg2 = 0 ;
20541   Dali::Property::Index result;
20542
20543   arg1 = (Dali::Handle *)jarg1;
20544   if (!jarg2) {
20545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20546     return 0;
20547   }
20548   std::string arg2_str(jarg2);
20549   arg2 = &arg2_str;
20550   {
20551     try {
20552       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20553     } catch (std::out_of_range& e) {
20554       {
20555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20556       };
20557     } catch (std::exception& e) {
20558       {
20559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20560       };
20561     } catch (Dali::DaliException e) {
20562       {
20563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20564       };
20565     } catch (...) {
20566       {
20567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20568       };
20569     }
20570   }
20571
20572   jresult = result;
20573
20574   //argout typemap for const std::string&
20575
20576   return jresult;
20577 }
20578
20579
20580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20581   unsigned int jresult ;
20582   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20583   Dali::Property::Index arg2 ;
20584   bool result;
20585
20586   arg1 = (Dali::Handle *)jarg1;
20587   arg2 = (Dali::Property::Index)jarg2;
20588   {
20589     try {
20590       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20591     } catch (std::out_of_range& e) {
20592       {
20593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20594       };
20595     } catch (std::exception& e) {
20596       {
20597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20598       };
20599     } catch (Dali::DaliException e) {
20600       {
20601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20602       };
20603     } catch (...) {
20604       {
20605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20606       };
20607     }
20608   }
20609
20610   jresult = result;
20611   return jresult;
20612 }
20613
20614
20615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20616   unsigned int jresult ;
20617   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20618   Dali::Property::Index arg2 ;
20619   bool result;
20620
20621   arg1 = (Dali::Handle *)jarg1;
20622   arg2 = (Dali::Property::Index)jarg2;
20623   {
20624     try {
20625       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20626     } catch (std::out_of_range& e) {
20627       {
20628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20629       };
20630     } catch (std::exception& e) {
20631       {
20632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20633       };
20634     } catch (Dali::DaliException e) {
20635       {
20636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20637       };
20638     } catch (...) {
20639       {
20640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20641       };
20642     }
20643   }
20644
20645   jresult = result;
20646   return jresult;
20647 }
20648
20649
20650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20651   unsigned int jresult ;
20652   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20653   Dali::Property::Index arg2 ;
20654   bool result;
20655
20656   arg1 = (Dali::Handle *)jarg1;
20657   arg2 = (Dali::Property::Index)jarg2;
20658   {
20659     try {
20660       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20661     } catch (std::out_of_range& e) {
20662       {
20663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20664       };
20665     } catch (std::exception& e) {
20666       {
20667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20668       };
20669     } catch (Dali::DaliException e) {
20670       {
20671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20672       };
20673     } catch (...) {
20674       {
20675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20676       };
20677     }
20678   }
20679
20680   jresult = result;
20681   return jresult;
20682 }
20683
20684
20685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20686   int jresult ;
20687   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20688   Dali::Property::Index arg2 ;
20689   Dali::Property::Type result;
20690
20691   arg1 = (Dali::Handle *)jarg1;
20692   arg2 = (Dali::Property::Index)jarg2;
20693   {
20694     try {
20695       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20696     } catch (std::out_of_range& e) {
20697       {
20698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20699       };
20700     } catch (std::exception& e) {
20701       {
20702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20703       };
20704     } catch (Dali::DaliException e) {
20705       {
20706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20707       };
20708     } catch (...) {
20709       {
20710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20711       };
20712     }
20713   }
20714
20715   jresult = (int)result;
20716   return jresult;
20717 }
20718
20719
20720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20721   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20722   Dali::Property::Index arg2 ;
20723   Dali::Property::Value *arg3 = 0 ;
20724
20725   arg1 = (Dali::Handle *)jarg1;
20726   arg2 = (Dali::Property::Index)jarg2;
20727   arg3 = (Dali::Property::Value *)jarg3;
20728   if (!arg3) {
20729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20730     return ;
20731   }
20732   {
20733     try {
20734       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20735     } catch (std::out_of_range& e) {
20736       {
20737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20738       };
20739     } catch (std::exception& e) {
20740       {
20741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20742       };
20743     } catch (Dali::DaliException e) {
20744       {
20745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20746       };
20747     } catch (...) {
20748       {
20749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20750       };
20751     }
20752   }
20753
20754 }
20755
20756
20757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20758   int jresult ;
20759   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20760   std::string *arg2 = 0 ;
20761   Dali::Property::Value *arg3 = 0 ;
20762   Dali::Property::Index result;
20763
20764   arg1 = (Dali::Handle *)jarg1;
20765   if (!jarg2) {
20766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20767     return 0;
20768   }
20769   std::string arg2_str(jarg2);
20770   arg2 = &arg2_str;
20771   arg3 = (Dali::Property::Value *)jarg3;
20772   if (!arg3) {
20773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20774     return 0;
20775   }
20776   {
20777     try {
20778       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20779     } catch (std::out_of_range& e) {
20780       {
20781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20782       };
20783     } catch (std::exception& e) {
20784       {
20785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20786       };
20787     } catch (Dali::DaliException e) {
20788       {
20789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20790       };
20791     } catch (...) {
20792       {
20793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20794       };
20795     }
20796   }
20797
20798   jresult = result;
20799
20800   //argout typemap for const std::string&
20801
20802   return jresult;
20803 }
20804
20805
20806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20807   int jresult ;
20808   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20809   std::string *arg2 = 0 ;
20810   Dali::Property::Value *arg3 = 0 ;
20811   Dali::Property::AccessMode arg4 ;
20812   Dali::Property::Index result;
20813
20814   arg1 = (Dali::Handle *)jarg1;
20815   if (!jarg2) {
20816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20817     return 0;
20818   }
20819   std::string arg2_str(jarg2);
20820   arg2 = &arg2_str;
20821   arg3 = (Dali::Property::Value *)jarg3;
20822   if (!arg3) {
20823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20824     return 0;
20825   }
20826   arg4 = (Dali::Property::AccessMode)jarg4;
20827   {
20828     try {
20829       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20830     } catch (std::out_of_range& e) {
20831       {
20832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20833       };
20834     } catch (std::exception& e) {
20835       {
20836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20837       };
20838     } catch (Dali::DaliException e) {
20839       {
20840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20841       };
20842     } catch (...) {
20843       {
20844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20845       };
20846     }
20847   }
20848
20849   jresult = result;
20850
20851   //argout typemap for const std::string&
20852
20853   return jresult;
20854 }
20855
20856
20857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20858   void * jresult ;
20859   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20860   Dali::Property::Index arg2 ;
20861   Dali::Property::Value result;
20862
20863   arg1 = (Dali::Handle *)jarg1;
20864   arg2 = (Dali::Property::Index)jarg2;
20865   {
20866     try {
20867       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20868     } catch (std::out_of_range& e) {
20869       {
20870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20871       };
20872     } catch (std::exception& e) {
20873       {
20874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20875       };
20876     } catch (Dali::DaliException e) {
20877       {
20878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20879       };
20880     } catch (...) {
20881       {
20882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20883       };
20884     }
20885   }
20886
20887   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20888   return jresult;
20889 }
20890
20891
20892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20893   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20894   Dali::Property::IndexContainer *arg2 = 0 ;
20895
20896   arg1 = (Dali::Handle *)jarg1;
20897   arg2 = (Dali::Property::IndexContainer *)jarg2;
20898   if (!arg2) {
20899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20900     return ;
20901   }
20902   {
20903     try {
20904       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20905     } catch (std::out_of_range& e) {
20906       {
20907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20908       };
20909     } catch (std::exception& e) {
20910       {
20911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20912       };
20913     } catch (Dali::DaliException e) {
20914       {
20915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20916       };
20917     } catch (...) {
20918       {
20919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20920       };
20921     }
20922   }
20923
20924 }
20925
20926
20927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20928   void * jresult ;
20929   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20930   Dali::Property::Index arg2 ;
20931   Dali::PropertyCondition *arg3 = 0 ;
20932   Dali::PropertyNotification result;
20933
20934   arg1 = (Dali::Handle *)jarg1;
20935   arg2 = (Dali::Property::Index)jarg2;
20936   arg3 = (Dali::PropertyCondition *)jarg3;
20937   if (!arg3) {
20938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20939     return 0;
20940   }
20941   {
20942     try {
20943       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20944     } catch (std::out_of_range& e) {
20945       {
20946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20947       };
20948     } catch (std::exception& e) {
20949       {
20950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20951       };
20952     } catch (Dali::DaliException e) {
20953       {
20954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20955       };
20956     } catch (...) {
20957       {
20958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20959       };
20960     }
20961   }
20962
20963   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20964   return jresult;
20965 }
20966
20967
20968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20969   void * jresult ;
20970   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20971   Dali::Property::Index arg2 ;
20972   int arg3 ;
20973   Dali::PropertyCondition *arg4 = 0 ;
20974   Dali::PropertyNotification result;
20975
20976   arg1 = (Dali::Handle *)jarg1;
20977   arg2 = (Dali::Property::Index)jarg2;
20978   arg3 = (int)jarg3;
20979   arg4 = (Dali::PropertyCondition *)jarg4;
20980   if (!arg4) {
20981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20982     return 0;
20983   }
20984   {
20985     try {
20986       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20987     } catch (std::out_of_range& e) {
20988       {
20989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20990       };
20991     } catch (std::exception& e) {
20992       {
20993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20994       };
20995     } catch (Dali::DaliException e) {
20996       {
20997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20998       };
20999     } catch (...) {
21000       {
21001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21002       };
21003     }
21004   }
21005
21006   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21007   return jresult;
21008 }
21009
21010
21011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21012   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21013   Dali::PropertyNotification arg2 ;
21014   Dali::PropertyNotification *argp2 ;
21015
21016   arg1 = (Dali::Handle *)jarg1;
21017   argp2 = (Dali::PropertyNotification *)jarg2;
21018   if (!argp2) {
21019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21020     return ;
21021   }
21022   arg2 = *argp2;
21023   {
21024     try {
21025       (arg1)->RemovePropertyNotification(arg2);
21026     } catch (std::out_of_range& e) {
21027       {
21028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21029       };
21030     } catch (std::exception& e) {
21031       {
21032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21033       };
21034     } catch (Dali::DaliException e) {
21035       {
21036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21037       };
21038     } catch (...) {
21039       {
21040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21041       };
21042     }
21043   }
21044
21045 }
21046
21047
21048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21049   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21050
21051   arg1 = (Dali::Handle *)jarg1;
21052   {
21053     try {
21054       (arg1)->RemovePropertyNotifications();
21055     } catch (std::out_of_range& e) {
21056       {
21057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21058       };
21059     } catch (std::exception& e) {
21060       {
21061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21062       };
21063     } catch (Dali::DaliException e) {
21064       {
21065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21066       };
21067     } catch (...) {
21068       {
21069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21070       };
21071     }
21072   }
21073
21074 }
21075
21076
21077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21078   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21079
21080   arg1 = (Dali::Handle *)jarg1;
21081   {
21082     try {
21083       (arg1)->RemoveConstraints();
21084     } catch (std::out_of_range& e) {
21085       {
21086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21087       };
21088     } catch (std::exception& e) {
21089       {
21090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21091       };
21092     } catch (Dali::DaliException e) {
21093       {
21094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21095       };
21096     } catch (...) {
21097       {
21098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21099       };
21100     }
21101   }
21102
21103 }
21104
21105
21106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21107   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21108   unsigned int arg2 ;
21109
21110   arg1 = (Dali::Handle *)jarg1;
21111   arg2 = (unsigned int)jarg2;
21112   {
21113     try {
21114       (arg1)->RemoveConstraints(arg2);
21115     } catch (std::out_of_range& e) {
21116       {
21117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21118       };
21119     } catch (std::exception& e) {
21120       {
21121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21122       };
21123     } catch (Dali::DaliException e) {
21124       {
21125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21126       };
21127     } catch (...) {
21128       {
21129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21130       };
21131     }
21132   }
21133
21134 }
21135
21136
21137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21138   int jresult ;
21139   Dali::Property::Index result;
21140
21141   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21142   jresult = result;
21143   return jresult;
21144 }
21145
21146
21147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21148   void * jresult ;
21149   Dali::Handle result;
21150
21151   {
21152     try {
21153       result = Dali::WeightObject::New();
21154     } catch (std::out_of_range& e) {
21155       {
21156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21157       };
21158     } catch (std::exception& e) {
21159       {
21160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21161       };
21162     } catch (Dali::DaliException e) {
21163       {
21164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21165       };
21166     } catch (...) {
21167       {
21168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21169       };
21170     }
21171   }
21172
21173   jresult = new Dali::Handle((const Dali::Handle &)result);
21174   return jresult;
21175 }
21176
21177
21178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21179   void * jresult ;
21180   Dali::TypeInfo *result = 0 ;
21181
21182   {
21183     try {
21184       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21185     } catch (std::out_of_range& e) {
21186       {
21187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21188       };
21189     } catch (std::exception& e) {
21190       {
21191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21192       };
21193     } catch (Dali::DaliException e) {
21194       {
21195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21196       };
21197     } catch (...) {
21198       {
21199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21200       };
21201     }
21202   }
21203
21204   jresult = (void *)result;
21205   return jresult;
21206 }
21207
21208
21209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21210   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21211
21212   arg1 = (Dali::TypeInfo *)jarg1;
21213   {
21214     try {
21215       delete arg1;
21216     } catch (std::out_of_range& e) {
21217       {
21218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21219       };
21220     } catch (std::exception& e) {
21221       {
21222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21223       };
21224     } catch (Dali::DaliException e) {
21225       {
21226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21227       };
21228     } catch (...) {
21229       {
21230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21231       };
21232     }
21233   }
21234
21235 }
21236
21237
21238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21239   void * jresult ;
21240   Dali::TypeInfo *arg1 = 0 ;
21241   Dali::TypeInfo *result = 0 ;
21242
21243   arg1 = (Dali::TypeInfo *)jarg1;
21244   if (!arg1) {
21245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21246     return 0;
21247   }
21248   {
21249     try {
21250       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21251     } catch (std::out_of_range& e) {
21252       {
21253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21254       };
21255     } catch (std::exception& e) {
21256       {
21257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21258       };
21259     } catch (Dali::DaliException e) {
21260       {
21261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21262       };
21263     } catch (...) {
21264       {
21265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21266       };
21267     }
21268   }
21269
21270   jresult = (void *)result;
21271   return jresult;
21272 }
21273
21274
21275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21276   void * jresult ;
21277   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21278   Dali::TypeInfo *arg2 = 0 ;
21279   Dali::TypeInfo *result = 0 ;
21280
21281   arg1 = (Dali::TypeInfo *)jarg1;
21282   arg2 = (Dali::TypeInfo *)jarg2;
21283   if (!arg2) {
21284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21285     return 0;
21286   }
21287   {
21288     try {
21289       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21290     } catch (std::out_of_range& e) {
21291       {
21292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21293       };
21294     } catch (std::exception& e) {
21295       {
21296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21297       };
21298     } catch (Dali::DaliException e) {
21299       {
21300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21301       };
21302     } catch (...) {
21303       {
21304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21305       };
21306     }
21307   }
21308
21309   jresult = (void *)result;
21310   return jresult;
21311 }
21312
21313
21314 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21315   char * jresult ;
21316   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21317   std::string *result = 0 ;
21318
21319   arg1 = (Dali::TypeInfo *)jarg1;
21320   {
21321     try {
21322       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21323     } catch (std::out_of_range& e) {
21324       {
21325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21326       };
21327     } catch (std::exception& e) {
21328       {
21329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21330       };
21331     } catch (Dali::DaliException e) {
21332       {
21333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21334       };
21335     } catch (...) {
21336       {
21337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21338       };
21339     }
21340   }
21341
21342   jresult = SWIG_csharp_string_callback(result->c_str());
21343   return jresult;
21344 }
21345
21346
21347 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21348   char * jresult ;
21349   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21350   std::string *result = 0 ;
21351
21352   arg1 = (Dali::TypeInfo *)jarg1;
21353   {
21354     try {
21355       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21356     } catch (std::out_of_range& e) {
21357       {
21358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21359       };
21360     } catch (std::exception& e) {
21361       {
21362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21363       };
21364     } catch (Dali::DaliException e) {
21365       {
21366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21367       };
21368     } catch (...) {
21369       {
21370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21371       };
21372     }
21373   }
21374
21375   jresult = SWIG_csharp_string_callback(result->c_str());
21376   return jresult;
21377 }
21378
21379
21380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21381   void * jresult ;
21382   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21383   Dali::BaseHandle result;
21384
21385   arg1 = (Dali::TypeInfo *)jarg1;
21386   {
21387     try {
21388       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21389     } catch (std::out_of_range& e) {
21390       {
21391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21392       };
21393     } catch (std::exception& e) {
21394       {
21395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21396       };
21397     } catch (Dali::DaliException e) {
21398       {
21399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21400       };
21401     } catch (...) {
21402       {
21403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21404       };
21405     }
21406   }
21407
21408   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21409   return jresult;
21410 }
21411
21412
21413 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21414   unsigned long jresult ;
21415   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21416   size_t result;
21417
21418   arg1 = (Dali::TypeInfo *)jarg1;
21419   {
21420     try {
21421       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21422     } catch (std::out_of_range& e) {
21423       {
21424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21425       };
21426     } catch (std::exception& e) {
21427       {
21428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21429       };
21430     } catch (Dali::DaliException e) {
21431       {
21432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21433       };
21434     } catch (...) {
21435       {
21436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21437       };
21438     }
21439   }
21440
21441   jresult = (unsigned long)result;
21442   return jresult;
21443 }
21444
21445
21446 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21447   char * jresult ;
21448   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21449   size_t arg2 ;
21450   std::string result;
21451
21452   arg1 = (Dali::TypeInfo *)jarg1;
21453   arg2 = (size_t)jarg2;
21454   {
21455     try {
21456       result = (arg1)->GetActionName(arg2);
21457     } catch (std::out_of_range& e) {
21458       {
21459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21460       };
21461     } catch (std::exception& e) {
21462       {
21463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21464       };
21465     } catch (Dali::DaliException e) {
21466       {
21467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21468       };
21469     } catch (...) {
21470       {
21471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21472       };
21473     }
21474   }
21475
21476   jresult = SWIG_csharp_string_callback((&result)->c_str());
21477   return jresult;
21478 }
21479
21480
21481 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21482   unsigned long jresult ;
21483   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21484   size_t result;
21485
21486   arg1 = (Dali::TypeInfo *)jarg1;
21487   {
21488     try {
21489       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21490     } catch (std::out_of_range& e) {
21491       {
21492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21493       };
21494     } catch (std::exception& e) {
21495       {
21496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21497       };
21498     } catch (Dali::DaliException e) {
21499       {
21500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21501       };
21502     } catch (...) {
21503       {
21504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21505       };
21506     }
21507   }
21508
21509   jresult = (unsigned long)result;
21510   return jresult;
21511 }
21512
21513
21514 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21515   char * jresult ;
21516   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21517   size_t arg2 ;
21518   std::string result;
21519
21520   arg1 = (Dali::TypeInfo *)jarg1;
21521   arg2 = (size_t)jarg2;
21522   {
21523     try {
21524       result = (arg1)->GetSignalName(arg2);
21525     } catch (std::out_of_range& e) {
21526       {
21527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21528       };
21529     } catch (std::exception& e) {
21530       {
21531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21532       };
21533     } catch (Dali::DaliException e) {
21534       {
21535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21536       };
21537     } catch (...) {
21538       {
21539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21540       };
21541     }
21542   }
21543
21544   jresult = SWIG_csharp_string_callback((&result)->c_str());
21545   return jresult;
21546 }
21547
21548
21549 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21550   unsigned long jresult ;
21551   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21552   size_t result;
21553
21554   arg1 = (Dali::TypeInfo *)jarg1;
21555   {
21556     try {
21557       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21558     } catch (std::out_of_range& e) {
21559       {
21560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21561       };
21562     } catch (std::exception& e) {
21563       {
21564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21565       };
21566     } catch (Dali::DaliException e) {
21567       {
21568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21569       };
21570     } catch (...) {
21571       {
21572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21573       };
21574     }
21575   }
21576
21577   jresult = (unsigned long)result;
21578   return jresult;
21579 }
21580
21581
21582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21583   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21584   Dali::Property::IndexContainer *arg2 = 0 ;
21585
21586   arg1 = (Dali::TypeInfo *)jarg1;
21587   arg2 = (Dali::Property::IndexContainer *)jarg2;
21588   if (!arg2) {
21589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21590     return ;
21591   }
21592   {
21593     try {
21594       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21595     } catch (std::out_of_range& e) {
21596       {
21597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21598       };
21599     } catch (std::exception& e) {
21600       {
21601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21602       };
21603     } catch (Dali::DaliException e) {
21604       {
21605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21606       };
21607     } catch (...) {
21608       {
21609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21610       };
21611     }
21612   }
21613
21614 }
21615
21616
21617 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21618   char * jresult ;
21619   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21620   Dali::Property::Index arg2 ;
21621   std::string *result = 0 ;
21622
21623   arg1 = (Dali::TypeInfo *)jarg1;
21624   arg2 = (Dali::Property::Index)jarg2;
21625   {
21626     try {
21627       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21628     } catch (std::out_of_range& e) {
21629       {
21630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21631       };
21632     } catch (std::exception& e) {
21633       {
21634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21635       };
21636     } catch (Dali::DaliException e) {
21637       {
21638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21639       };
21640     } catch (...) {
21641       {
21642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21643       };
21644     }
21645   }
21646
21647   jresult = SWIG_csharp_string_callback(result->c_str());
21648   return jresult;
21649 }
21650
21651
21652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21653   void * jresult ;
21654   Dali::TypeRegistry result;
21655
21656   {
21657     try {
21658       result = Dali::TypeRegistry::Get();
21659     } catch (std::out_of_range& e) {
21660       {
21661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21662       };
21663     } catch (std::exception& e) {
21664       {
21665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21666       };
21667     } catch (Dali::DaliException e) {
21668       {
21669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21670       };
21671     } catch (...) {
21672       {
21673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21674       };
21675     }
21676   }
21677
21678   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21679   return jresult;
21680 }
21681
21682
21683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21684   void * jresult ;
21685   Dali::TypeRegistry *result = 0 ;
21686
21687   {
21688     try {
21689       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21690     } catch (std::out_of_range& e) {
21691       {
21692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21693       };
21694     } catch (std::exception& e) {
21695       {
21696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21697       };
21698     } catch (Dali::DaliException e) {
21699       {
21700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21701       };
21702     } catch (...) {
21703       {
21704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21705       };
21706     }
21707   }
21708
21709   jresult = (void *)result;
21710   return jresult;
21711 }
21712
21713
21714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21715   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21716
21717   arg1 = (Dali::TypeRegistry *)jarg1;
21718   {
21719     try {
21720       delete arg1;
21721     } catch (std::out_of_range& e) {
21722       {
21723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21724       };
21725     } catch (std::exception& e) {
21726       {
21727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21728       };
21729     } catch (Dali::DaliException e) {
21730       {
21731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21732       };
21733     } catch (...) {
21734       {
21735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21736       };
21737     }
21738   }
21739
21740 }
21741
21742
21743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21744   void * jresult ;
21745   Dali::TypeRegistry *arg1 = 0 ;
21746   Dali::TypeRegistry *result = 0 ;
21747
21748   arg1 = (Dali::TypeRegistry *)jarg1;
21749   if (!arg1) {
21750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21751     return 0;
21752   }
21753   {
21754     try {
21755       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21756     } catch (std::out_of_range& e) {
21757       {
21758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21759       };
21760     } catch (std::exception& e) {
21761       {
21762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21763       };
21764     } catch (Dali::DaliException e) {
21765       {
21766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21767       };
21768     } catch (...) {
21769       {
21770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21771       };
21772     }
21773   }
21774
21775   jresult = (void *)result;
21776   return jresult;
21777 }
21778
21779
21780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21781   void * jresult ;
21782   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21783   Dali::TypeRegistry *arg2 = 0 ;
21784   Dali::TypeRegistry *result = 0 ;
21785
21786   arg1 = (Dali::TypeRegistry *)jarg1;
21787   arg2 = (Dali::TypeRegistry *)jarg2;
21788   if (!arg2) {
21789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21790     return 0;
21791   }
21792   {
21793     try {
21794       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21795     } catch (std::out_of_range& e) {
21796       {
21797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21798       };
21799     } catch (std::exception& e) {
21800       {
21801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21802       };
21803     } catch (Dali::DaliException e) {
21804       {
21805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21806       };
21807     } catch (...) {
21808       {
21809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21810       };
21811     }
21812   }
21813
21814   jresult = (void *)result;
21815   return jresult;
21816 }
21817
21818
21819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21820   void * jresult ;
21821   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21822   std::string *arg2 = 0 ;
21823   Dali::TypeInfo result;
21824
21825   arg1 = (Dali::TypeRegistry *)jarg1;
21826   if (!jarg2) {
21827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21828     return 0;
21829   }
21830   std::string arg2_str(jarg2);
21831   arg2 = &arg2_str;
21832   {
21833     try {
21834       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21835     } catch (std::out_of_range& e) {
21836       {
21837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21838       };
21839     } catch (std::exception& e) {
21840       {
21841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21842       };
21843     } catch (Dali::DaliException e) {
21844       {
21845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21846       };
21847     } catch (...) {
21848       {
21849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21850       };
21851     }
21852   }
21853
21854   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21855
21856   //argout typemap for const std::string&
21857
21858   return jresult;
21859 }
21860
21861
21862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21863   void * jresult ;
21864   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21865   std::type_info *arg2 = 0 ;
21866   Dali::TypeInfo result;
21867
21868   arg1 = (Dali::TypeRegistry *)jarg1;
21869   arg2 = (std::type_info *)jarg2;
21870   if (!arg2) {
21871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21872     return 0;
21873   }
21874   {
21875     try {
21876       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21877     } catch (std::out_of_range& e) {
21878       {
21879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21880       };
21881     } catch (std::exception& e) {
21882       {
21883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21884       };
21885     } catch (Dali::DaliException e) {
21886       {
21887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21888       };
21889     } catch (...) {
21890       {
21891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21892       };
21893     }
21894   }
21895
21896   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21897   return jresult;
21898 }
21899
21900
21901 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21902   unsigned long jresult ;
21903   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21904   size_t result;
21905
21906   arg1 = (Dali::TypeRegistry *)jarg1;
21907   {
21908     try {
21909       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21910     } catch (std::out_of_range& e) {
21911       {
21912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21913       };
21914     } catch (std::exception& e) {
21915       {
21916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21917       };
21918     } catch (Dali::DaliException e) {
21919       {
21920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21921       };
21922     } catch (...) {
21923       {
21924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21925       };
21926     }
21927   }
21928
21929   jresult = (unsigned long)result;
21930   return jresult;
21931 }
21932
21933
21934 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21935   char * jresult ;
21936   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21937   size_t arg2 ;
21938   std::string result;
21939
21940   arg1 = (Dali::TypeRegistry *)jarg1;
21941   arg2 = (size_t)jarg2;
21942   {
21943     try {
21944       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21945     } catch (std::out_of_range& e) {
21946       {
21947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21948       };
21949     } catch (std::exception& e) {
21950       {
21951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21952       };
21953     } catch (Dali::DaliException e) {
21954       {
21955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21956       };
21957     } catch (...) {
21958       {
21959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21960       };
21961     }
21962   }
21963
21964   jresult = SWIG_csharp_string_callback((&result)->c_str());
21965   return jresult;
21966 }
21967
21968
21969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21970   void * jresult ;
21971   std::type_info *arg1 = 0 ;
21972   std::type_info *arg2 = 0 ;
21973   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21974   Dali::TypeRegistration *result = 0 ;
21975
21976   arg1 = (std::type_info *)jarg1;
21977   if (!arg1) {
21978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21979     return 0;
21980   }
21981   arg2 = (std::type_info *)jarg2;
21982   if (!arg2) {
21983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21984     return 0;
21985   }
21986   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21987   {
21988     try {
21989       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21990     } catch (std::out_of_range& e) {
21991       {
21992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21993       };
21994     } catch (std::exception& e) {
21995       {
21996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21997       };
21998     } catch (Dali::DaliException e) {
21999       {
22000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22001       };
22002     } catch (...) {
22003       {
22004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22005       };
22006     }
22007   }
22008
22009   jresult = (void *)result;
22010   return jresult;
22011 }
22012
22013
22014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22015   void * jresult ;
22016   std::type_info *arg1 = 0 ;
22017   std::type_info *arg2 = 0 ;
22018   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22019   bool arg4 ;
22020   Dali::TypeRegistration *result = 0 ;
22021
22022   arg1 = (std::type_info *)jarg1;
22023   if (!arg1) {
22024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22025     return 0;
22026   }
22027   arg2 = (std::type_info *)jarg2;
22028   if (!arg2) {
22029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22030     return 0;
22031   }
22032   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22033   arg4 = jarg4 ? true : false;
22034   {
22035     try {
22036       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22037     } catch (std::out_of_range& e) {
22038       {
22039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22040       };
22041     } catch (std::exception& e) {
22042       {
22043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22044       };
22045     } catch (Dali::DaliException e) {
22046       {
22047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22048       };
22049     } catch (...) {
22050       {
22051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22052       };
22053     }
22054   }
22055
22056   jresult = (void *)result;
22057   return jresult;
22058 }
22059
22060
22061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22062   void * jresult ;
22063   std::string *arg1 = 0 ;
22064   std::type_info *arg2 = 0 ;
22065   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22066   Dali::TypeRegistration *result = 0 ;
22067
22068   if (!jarg1) {
22069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22070     return 0;
22071   }
22072   std::string arg1_str(jarg1);
22073   arg1 = &arg1_str;
22074   arg2 = (std::type_info *)jarg2;
22075   if (!arg2) {
22076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22077     return 0;
22078   }
22079   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22080   {
22081     try {
22082       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22083     } catch (std::out_of_range& e) {
22084       {
22085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22086       };
22087     } catch (std::exception& e) {
22088       {
22089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22090       };
22091     } catch (Dali::DaliException e) {
22092       {
22093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22094       };
22095     } catch (...) {
22096       {
22097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22098       };
22099     }
22100   }
22101
22102   jresult = (void *)result;
22103
22104   //argout typemap for const std::string&
22105
22106   return jresult;
22107 }
22108
22109
22110 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22111   char * jresult ;
22112   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22113   std::string result;
22114
22115   arg1 = (Dali::TypeRegistration *)jarg1;
22116   {
22117     try {
22118       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22119     } catch (std::out_of_range& e) {
22120       {
22121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22122       };
22123     } catch (std::exception& e) {
22124       {
22125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22126       };
22127     } catch (Dali::DaliException e) {
22128       {
22129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22130       };
22131     } catch (...) {
22132       {
22133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22134       };
22135     }
22136   }
22137
22138   jresult = SWIG_csharp_string_callback((&result)->c_str());
22139   return jresult;
22140 }
22141
22142
22143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22144   std::string *arg1 = 0 ;
22145   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22146
22147   if (!jarg1) {
22148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22149     return ;
22150   }
22151   std::string arg1_str(jarg1);
22152   arg1 = &arg1_str;
22153   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22154   {
22155     try {
22156       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22157     } catch (std::out_of_range& e) {
22158       {
22159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22160       };
22161     } catch (std::exception& e) {
22162       {
22163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22164       };
22165     } catch (Dali::DaliException e) {
22166       {
22167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22168       };
22169     } catch (...) {
22170       {
22171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22172       };
22173     }
22174   }
22175
22176
22177   //argout typemap for const std::string&
22178
22179 }
22180
22181
22182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22183   std::string *arg1 = 0 ;
22184   std::string *arg2 = 0 ;
22185   int arg3 ;
22186   Dali::Property::Type arg4 ;
22187   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22188   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22189
22190   if (!jarg1) {
22191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22192     return ;
22193   }
22194   std::string arg1_str(jarg1);
22195   arg1 = &arg1_str;
22196   if (!jarg2) {
22197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22198     return ;
22199   }
22200   std::string arg2_str(jarg2);
22201   arg2 = &arg2_str;
22202   arg3 = (int)jarg3;
22203   arg4 = (Dali::Property::Type)jarg4;
22204   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22205   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22206   {
22207     try {
22208       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22209     } catch (std::out_of_range& e) {
22210       {
22211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22212       };
22213     } catch (std::exception& e) {
22214       {
22215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22216       };
22217     } catch (Dali::DaliException e) {
22218       {
22219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22220       };
22221     } catch (...) {
22222       {
22223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22224       };
22225     }
22226   }
22227
22228
22229   //argout typemap for const std::string&
22230
22231
22232   //argout typemap for const std::string&
22233
22234 }
22235
22236
22237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22238   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22239
22240   arg1 = (Dali::TypeRegistration *)jarg1;
22241   {
22242     try {
22243       delete arg1;
22244     } catch (std::out_of_range& e) {
22245       {
22246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22247       };
22248     } catch (std::exception& e) {
22249       {
22250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22251       };
22252     } catch (Dali::DaliException e) {
22253       {
22254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22255       };
22256     } catch (...) {
22257       {
22258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22259       };
22260     }
22261   }
22262
22263 }
22264
22265
22266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22267   void * jresult ;
22268   Dali::TypeRegistration *arg1 = 0 ;
22269   std::string *arg2 = 0 ;
22270   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22271   Dali::SignalConnectorType *result = 0 ;
22272
22273   arg1 = (Dali::TypeRegistration *)jarg1;
22274   if (!arg1) {
22275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22276     return 0;
22277   }
22278   if (!jarg2) {
22279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22280     return 0;
22281   }
22282   std::string arg2_str(jarg2);
22283   arg2 = &arg2_str;
22284   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22285   {
22286     try {
22287       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22288     } catch (std::out_of_range& e) {
22289       {
22290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22291       };
22292     } catch (std::exception& e) {
22293       {
22294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22295       };
22296     } catch (Dali::DaliException e) {
22297       {
22298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22299       };
22300     } catch (...) {
22301       {
22302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22303       };
22304     }
22305   }
22306
22307   jresult = (void *)result;
22308
22309   //argout typemap for const std::string&
22310
22311   return jresult;
22312 }
22313
22314
22315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22316   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22317
22318   arg1 = (Dali::SignalConnectorType *)jarg1;
22319   {
22320     try {
22321       delete arg1;
22322     } catch (std::out_of_range& e) {
22323       {
22324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22325       };
22326     } catch (std::exception& e) {
22327       {
22328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22329       };
22330     } catch (Dali::DaliException e) {
22331       {
22332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22333       };
22334     } catch (...) {
22335       {
22336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22337       };
22338     }
22339   }
22340
22341 }
22342
22343
22344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22345   void * jresult ;
22346   Dali::TypeRegistration *arg1 = 0 ;
22347   std::string *arg2 = 0 ;
22348   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22349   Dali::TypeAction *result = 0 ;
22350
22351   arg1 = (Dali::TypeRegistration *)jarg1;
22352   if (!arg1) {
22353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22354     return 0;
22355   }
22356   if (!jarg2) {
22357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22358     return 0;
22359   }
22360   std::string arg2_str(jarg2);
22361   arg2 = &arg2_str;
22362   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22363   {
22364     try {
22365       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22366     } catch (std::out_of_range& e) {
22367       {
22368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22369       };
22370     } catch (std::exception& e) {
22371       {
22372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22373       };
22374     } catch (Dali::DaliException e) {
22375       {
22376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22377       };
22378     } catch (...) {
22379       {
22380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22381       };
22382     }
22383   }
22384
22385   jresult = (void *)result;
22386
22387   //argout typemap for const std::string&
22388
22389   return jresult;
22390 }
22391
22392
22393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22394   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22395
22396   arg1 = (Dali::TypeAction *)jarg1;
22397   {
22398     try {
22399       delete arg1;
22400     } catch (std::out_of_range& e) {
22401       {
22402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22403       };
22404     } catch (std::exception& e) {
22405       {
22406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22407       };
22408     } catch (Dali::DaliException e) {
22409       {
22410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22411       };
22412     } catch (...) {
22413       {
22414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22415       };
22416     }
22417   }
22418
22419 }
22420
22421
22422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22423   void * jresult ;
22424   Dali::TypeRegistration *arg1 = 0 ;
22425   std::string *arg2 = 0 ;
22426   Dali::Property::Index arg3 ;
22427   Dali::Property::Type arg4 ;
22428   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22429   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22430   Dali::PropertyRegistration *result = 0 ;
22431
22432   arg1 = (Dali::TypeRegistration *)jarg1;
22433   if (!arg1) {
22434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22435     return 0;
22436   }
22437   if (!jarg2) {
22438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22439     return 0;
22440   }
22441   std::string arg2_str(jarg2);
22442   arg2 = &arg2_str;
22443   arg3 = (Dali::Property::Index)jarg3;
22444   arg4 = (Dali::Property::Type)jarg4;
22445   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22446   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22447   {
22448     try {
22449       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22450     } catch (std::out_of_range& e) {
22451       {
22452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22453       };
22454     } catch (std::exception& e) {
22455       {
22456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22457       };
22458     } catch (Dali::DaliException e) {
22459       {
22460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22461       };
22462     } catch (...) {
22463       {
22464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22465       };
22466     }
22467   }
22468
22469   jresult = (void *)result;
22470
22471   //argout typemap for const std::string&
22472
22473   return jresult;
22474 }
22475
22476
22477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22478   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22479
22480   arg1 = (Dali::PropertyRegistration *)jarg1;
22481   {
22482     try {
22483       delete arg1;
22484     } catch (std::out_of_range& e) {
22485       {
22486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22487       };
22488     } catch (std::exception& e) {
22489       {
22490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22491       };
22492     } catch (Dali::DaliException e) {
22493       {
22494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22495       };
22496     } catch (...) {
22497       {
22498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22499       };
22500     }
22501   }
22502
22503 }
22504
22505
22506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22507   void * jresult ;
22508   Dali::TypeRegistration *arg1 = 0 ;
22509   std::string *arg2 = 0 ;
22510   Dali::Property::Index arg3 ;
22511   Dali::Property::Type arg4 ;
22512   Dali::AnimatablePropertyRegistration *result = 0 ;
22513
22514   arg1 = (Dali::TypeRegistration *)jarg1;
22515   if (!arg1) {
22516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22517     return 0;
22518   }
22519   if (!jarg2) {
22520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22521     return 0;
22522   }
22523   std::string arg2_str(jarg2);
22524   arg2 = &arg2_str;
22525   arg3 = (Dali::Property::Index)jarg3;
22526   arg4 = (Dali::Property::Type)jarg4;
22527   {
22528     try {
22529       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22530     } catch (std::out_of_range& e) {
22531       {
22532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22533       };
22534     } catch (std::exception& e) {
22535       {
22536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22537       };
22538     } catch (Dali::DaliException e) {
22539       {
22540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22541       };
22542     } catch (...) {
22543       {
22544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22545       };
22546     }
22547   }
22548
22549   jresult = (void *)result;
22550
22551   //argout typemap for const std::string&
22552
22553   return jresult;
22554 }
22555
22556
22557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22558   void * jresult ;
22559   Dali::TypeRegistration *arg1 = 0 ;
22560   std::string *arg2 = 0 ;
22561   Dali::Property::Index arg3 ;
22562   Dali::Property::Value *arg4 = 0 ;
22563   Dali::AnimatablePropertyRegistration *result = 0 ;
22564
22565   arg1 = (Dali::TypeRegistration *)jarg1;
22566   if (!arg1) {
22567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22568     return 0;
22569   }
22570   if (!jarg2) {
22571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22572     return 0;
22573   }
22574   std::string arg2_str(jarg2);
22575   arg2 = &arg2_str;
22576   arg3 = (Dali::Property::Index)jarg3;
22577   arg4 = (Dali::Property::Value *)jarg4;
22578   if (!arg4) {
22579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22580     return 0;
22581   }
22582   {
22583     try {
22584       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22585     } catch (std::out_of_range& e) {
22586       {
22587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22588       };
22589     } catch (std::exception& e) {
22590       {
22591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22592       };
22593     } catch (Dali::DaliException e) {
22594       {
22595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22596       };
22597     } catch (...) {
22598       {
22599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22600       };
22601     }
22602   }
22603
22604   jresult = (void *)result;
22605
22606   //argout typemap for const std::string&
22607
22608   return jresult;
22609 }
22610
22611
22612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22613   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22614
22615   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22616   {
22617     try {
22618       delete arg1;
22619     } catch (std::out_of_range& e) {
22620       {
22621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22622       };
22623     } catch (std::exception& e) {
22624       {
22625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22626       };
22627     } catch (Dali::DaliException e) {
22628       {
22629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22630       };
22631     } catch (...) {
22632       {
22633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22634       };
22635     }
22636   }
22637
22638 }
22639
22640
22641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22642   void * jresult ;
22643   Dali::TypeRegistration *arg1 = 0 ;
22644   std::string *arg2 = 0 ;
22645   Dali::Property::Index arg3 ;
22646   Dali::Property::Index arg4 ;
22647   unsigned int arg5 ;
22648   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22649
22650   arg1 = (Dali::TypeRegistration *)jarg1;
22651   if (!arg1) {
22652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22653     return 0;
22654   }
22655   if (!jarg2) {
22656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22657     return 0;
22658   }
22659   std::string arg2_str(jarg2);
22660   arg2 = &arg2_str;
22661   arg3 = (Dali::Property::Index)jarg3;
22662   arg4 = (Dali::Property::Index)jarg4;
22663   arg5 = (unsigned int)jarg5;
22664   {
22665     try {
22666       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22667     } catch (std::out_of_range& e) {
22668       {
22669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22670       };
22671     } catch (std::exception& e) {
22672       {
22673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22674       };
22675     } catch (Dali::DaliException e) {
22676       {
22677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22678       };
22679     } catch (...) {
22680       {
22681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22682       };
22683     }
22684   }
22685
22686   jresult = (void *)result;
22687
22688   //argout typemap for const std::string&
22689
22690   return jresult;
22691 }
22692
22693
22694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22695   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22696
22697   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22698   {
22699     try {
22700       delete arg1;
22701     } catch (std::out_of_range& e) {
22702       {
22703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22704       };
22705     } catch (std::exception& e) {
22706       {
22707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22708       };
22709     } catch (Dali::DaliException e) {
22710       {
22711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22712       };
22713     } catch (...) {
22714       {
22715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22716       };
22717     }
22718   }
22719
22720 }
22721
22722
22723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22724   void * jresult ;
22725   Dali::TypeRegistration *arg1 = 0 ;
22726   std::string *arg2 = 0 ;
22727   Dali::Property::Index arg3 ;
22728   Dali::Property::Type arg4 ;
22729   Dali::ChildPropertyRegistration *result = 0 ;
22730
22731   arg1 = (Dali::TypeRegistration *)jarg1;
22732   if (!arg1) {
22733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22734     return 0;
22735   }
22736   if (!jarg2) {
22737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22738     return 0;
22739   }
22740   std::string arg2_str(jarg2);
22741   arg2 = &arg2_str;
22742   arg3 = (Dali::Property::Index)jarg3;
22743   arg4 = (Dali::Property::Type)jarg4;
22744   {
22745     try {
22746       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22747     } catch (std::out_of_range& e) {
22748       {
22749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22750       };
22751     } catch (std::exception& e) {
22752       {
22753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22754       };
22755     } catch (Dali::DaliException e) {
22756       {
22757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22758       };
22759     } catch (...) {
22760       {
22761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22762       };
22763     }
22764   }
22765
22766   jresult = (void *)result;
22767
22768   //argout typemap for const std::string&
22769
22770   return jresult;
22771 }
22772
22773
22774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22775   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22776
22777   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22778   {
22779     try {
22780       delete arg1;
22781     } catch (std::out_of_range& e) {
22782       {
22783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22784       };
22785     } catch (std::exception& e) {
22786       {
22787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22788       };
22789     } catch (Dali::DaliException e) {
22790       {
22791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22792       };
22793     } catch (...) {
22794       {
22795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22796       };
22797     }
22798   }
22799
22800 }
22801
22802
22803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22804   unsigned int jresult ;
22805   std::string *arg1 = 0 ;
22806   std::type_info *arg2 = 0 ;
22807   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22808   bool result;
22809
22810   if (!jarg1) {
22811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22812     return 0;
22813   }
22814   std::string arg1_str(jarg1);
22815   arg1 = &arg1_str;
22816   arg2 = (std::type_info *)jarg2;
22817   if (!arg2) {
22818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22819     return 0;
22820   }
22821   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22822   {
22823     try {
22824       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22825     } catch (std::out_of_range& e) {
22826       {
22827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22828       };
22829     } catch (std::exception& e) {
22830       {
22831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22832       };
22833     } catch (Dali::DaliException e) {
22834       {
22835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22836       };
22837     } catch (...) {
22838       {
22839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22840       };
22841     }
22842   }
22843
22844   jresult = result;
22845
22846   //argout typemap for const std::string&
22847
22848   return jresult;
22849 }
22850
22851
22852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22853   unsigned int jresult ;
22854   std::string *arg1 = 0 ;
22855   std::string *arg2 = 0 ;
22856   Dali::Property::Index arg3 ;
22857   Dali::Property::Type arg4 ;
22858   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22859   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22860   bool result;
22861
22862   if (!jarg1) {
22863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22864     return 0;
22865   }
22866   std::string arg1_str(jarg1);
22867   arg1 = &arg1_str;
22868   if (!jarg2) {
22869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22870     return 0;
22871   }
22872   std::string arg2_str(jarg2);
22873   arg2 = &arg2_str;
22874   arg3 = (Dali::Property::Index)jarg3;
22875   arg4 = (Dali::Property::Type)jarg4;
22876   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22877   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22878   {
22879     try {
22880       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22881     } catch (std::out_of_range& e) {
22882       {
22883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22884       };
22885     } catch (std::exception& e) {
22886       {
22887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22888       };
22889     } catch (Dali::DaliException e) {
22890       {
22891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22892       };
22893     } catch (...) {
22894       {
22895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22896       };
22897     }
22898   }
22899
22900   jresult = result;
22901
22902   //argout typemap for const std::string&
22903
22904
22905   //argout typemap for const std::string&
22906
22907   return jresult;
22908 }
22909
22910
22911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22912   float jresult ;
22913   float result;
22914
22915   result = (float)(float)Dali::ParentOrigin::TOP;
22916   jresult = result;
22917   return jresult;
22918 }
22919
22920
22921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22922   float jresult ;
22923   float result;
22924
22925   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22926   jresult = result;
22927   return jresult;
22928 }
22929
22930
22931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22932   float jresult ;
22933   float result;
22934
22935   result = (float)(float)Dali::ParentOrigin::LEFT;
22936   jresult = result;
22937   return jresult;
22938 }
22939
22940
22941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22942   float jresult ;
22943   float result;
22944
22945   result = (float)(float)Dali::ParentOrigin::RIGHT;
22946   jresult = result;
22947   return jresult;
22948 }
22949
22950
22951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22952   float jresult ;
22953   float result;
22954
22955   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22956   jresult = result;
22957   return jresult;
22958 }
22959
22960
22961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22962   void * jresult ;
22963   Dali::Vector3 *result = 0 ;
22964
22965   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22966   jresult = (void *)result;
22967   return jresult;
22968 }
22969
22970
22971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22972   void * jresult ;
22973   Dali::Vector3 *result = 0 ;
22974
22975   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22976   jresult = (void *)result;
22977   return jresult;
22978 }
22979
22980
22981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22982   void * jresult ;
22983   Dali::Vector3 *result = 0 ;
22984
22985   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22986   jresult = (void *)result;
22987   return jresult;
22988 }
22989
22990
22991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22992   void * jresult ;
22993   Dali::Vector3 *result = 0 ;
22994
22995   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22996   jresult = (void *)result;
22997   return jresult;
22998 }
22999
23000
23001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23002   void * jresult ;
23003   Dali::Vector3 *result = 0 ;
23004
23005   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23006   jresult = (void *)result;
23007   return jresult;
23008 }
23009
23010
23011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23012   void * jresult ;
23013   Dali::Vector3 *result = 0 ;
23014
23015   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23016   jresult = (void *)result;
23017   return jresult;
23018 }
23019
23020
23021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23022   void * jresult ;
23023   Dali::Vector3 *result = 0 ;
23024
23025   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23026   jresult = (void *)result;
23027   return jresult;
23028 }
23029
23030
23031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23032   void * jresult ;
23033   Dali::Vector3 *result = 0 ;
23034
23035   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23036   jresult = (void *)result;
23037   return jresult;
23038 }
23039
23040
23041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23042   void * jresult ;
23043   Dali::Vector3 *result = 0 ;
23044
23045   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23046   jresult = (void *)result;
23047   return jresult;
23048 }
23049
23050
23051 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23052   float jresult ;
23053   float result;
23054
23055   result = (float)(float)Dali::AnchorPoint::TOP;
23056   jresult = result;
23057   return jresult;
23058 }
23059
23060
23061 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23062   float jresult ;
23063   float result;
23064
23065   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23066   jresult = result;
23067   return jresult;
23068 }
23069
23070
23071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23072   float jresult ;
23073   float result;
23074
23075   result = (float)(float)Dali::AnchorPoint::LEFT;
23076   jresult = result;
23077   return jresult;
23078 }
23079
23080
23081 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23082   float jresult ;
23083   float result;
23084
23085   result = (float)(float)Dali::AnchorPoint::RIGHT;
23086   jresult = result;
23087   return jresult;
23088 }
23089
23090
23091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23092   float jresult ;
23093   float result;
23094
23095   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23096   jresult = result;
23097   return jresult;
23098 }
23099
23100
23101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23102   void * jresult ;
23103   Dali::Vector3 *result = 0 ;
23104
23105   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23106   jresult = (void *)result;
23107   return jresult;
23108 }
23109
23110
23111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23112   void * jresult ;
23113   Dali::Vector3 *result = 0 ;
23114
23115   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23116   jresult = (void *)result;
23117   return jresult;
23118 }
23119
23120
23121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23122   void * jresult ;
23123   Dali::Vector3 *result = 0 ;
23124
23125   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23126   jresult = (void *)result;
23127   return jresult;
23128 }
23129
23130
23131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23132   void * jresult ;
23133   Dali::Vector3 *result = 0 ;
23134
23135   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23136   jresult = (void *)result;
23137   return jresult;
23138 }
23139
23140
23141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23142   void * jresult ;
23143   Dali::Vector3 *result = 0 ;
23144
23145   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23146   jresult = (void *)result;
23147   return jresult;
23148 }
23149
23150
23151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23152   void * jresult ;
23153   Dali::Vector3 *result = 0 ;
23154
23155   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23156   jresult = (void *)result;
23157   return jresult;
23158 }
23159
23160
23161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23162   void * jresult ;
23163   Dali::Vector3 *result = 0 ;
23164
23165   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23166   jresult = (void *)result;
23167   return jresult;
23168 }
23169
23170
23171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23172   void * jresult ;
23173   Dali::Vector3 *result = 0 ;
23174
23175   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23176   jresult = (void *)result;
23177   return jresult;
23178 }
23179
23180
23181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23182   void * jresult ;
23183   Dali::Vector3 *result = 0 ;
23184
23185   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23186   jresult = (void *)result;
23187   return jresult;
23188 }
23189
23190
23191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23192   void * jresult ;
23193   Dali::Vector4 *result = 0 ;
23194
23195   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23196   jresult = (void *)result;
23197   return jresult;
23198 }
23199
23200
23201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23202   void * jresult ;
23203   Dali::Vector4 *result = 0 ;
23204
23205   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23206   jresult = (void *)result;
23207   return jresult;
23208 }
23209
23210
23211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23212   void * jresult ;
23213   Dali::Vector4 *result = 0 ;
23214
23215   result = (Dali::Vector4 *)&Dali::Color::RED;
23216   jresult = (void *)result;
23217   return jresult;
23218 }
23219
23220
23221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23222   void * jresult ;
23223   Dali::Vector4 *result = 0 ;
23224
23225   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23226   jresult = (void *)result;
23227   return jresult;
23228 }
23229
23230
23231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23232   void * jresult ;
23233   Dali::Vector4 *result = 0 ;
23234
23235   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23236   jresult = (void *)result;
23237   return jresult;
23238 }
23239
23240
23241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23242   void * jresult ;
23243   Dali::Vector4 *result = 0 ;
23244
23245   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23246   jresult = (void *)result;
23247   return jresult;
23248 }
23249
23250
23251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23252   void * jresult ;
23253   Dali::Vector4 *result = 0 ;
23254
23255   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23256   jresult = (void *)result;
23257   return jresult;
23258 }
23259
23260
23261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23262   void * jresult ;
23263   Dali::Vector4 *result = 0 ;
23264
23265   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23266   jresult = (void *)result;
23267   return jresult;
23268 }
23269
23270
23271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23272   void * jresult ;
23273   Dali::Vector4 *result = 0 ;
23274
23275   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23276   jresult = (void *)result;
23277   return jresult;
23278 }
23279
23280
23281 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23282   float jresult ;
23283   float result;
23284
23285   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23286   jresult = result;
23287   return jresult;
23288 }
23289
23290
23291 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23292   float jresult ;
23293   float result;
23294
23295   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23296   jresult = result;
23297   return jresult;
23298 }
23299
23300
23301 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23302   float jresult ;
23303   float result;
23304
23305   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23306   jresult = result;
23307   return jresult;
23308 }
23309
23310
23311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23312   float jresult ;
23313   float result;
23314
23315   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23316   jresult = result;
23317   return jresult;
23318 }
23319
23320
23321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23322   float jresult ;
23323   float result;
23324
23325   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23326   jresult = result;
23327   return jresult;
23328 }
23329
23330
23331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23332   float jresult ;
23333   float result;
23334
23335   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23336   jresult = result;
23337   return jresult;
23338 }
23339
23340
23341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23342   float jresult ;
23343   float result;
23344
23345   result = (float)(float)Dali::Math::PI;
23346   jresult = result;
23347   return jresult;
23348 }
23349
23350
23351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23352   float jresult ;
23353   float result;
23354
23355   result = (float)(float)Dali::Math::PI_2;
23356   jresult = result;
23357   return jresult;
23358 }
23359
23360
23361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23362   float jresult ;
23363   float result;
23364
23365   result = (float)(float)Dali::Math::PI_4;
23366   jresult = result;
23367   return jresult;
23368 }
23369
23370
23371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23372   float jresult ;
23373   float result;
23374
23375   result = (float)(float)Dali::Math::PI_OVER_180;
23376   jresult = result;
23377   return jresult;
23378 }
23379
23380
23381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23382   float jresult ;
23383   float result;
23384
23385   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23386   jresult = result;
23387   return jresult;
23388 }
23389
23390
23391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23392   int jresult ;
23393   Dali::ResizePolicy::Type result;
23394
23395   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23396   jresult = (int)result;
23397   return jresult;
23398 }
23399
23400
23401 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23402   unsigned long jresult ;
23403   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23404   Dali::VectorBase::SizeType result;
23405
23406   arg1 = (Dali::VectorBase *)jarg1;
23407   {
23408     try {
23409       result = ((Dali::VectorBase const *)arg1)->Count();
23410     } catch (std::out_of_range& e) {
23411       {
23412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23413       };
23414     } catch (std::exception& e) {
23415       {
23416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23417       };
23418     } catch (Dali::DaliException e) {
23419       {
23420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23421       };
23422     } catch (...) {
23423       {
23424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23425       };
23426     }
23427   }
23428
23429   jresult = (unsigned long)result;
23430   return jresult;
23431 }
23432
23433
23434 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23435   unsigned long jresult ;
23436   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23437   Dali::VectorBase::SizeType result;
23438
23439   arg1 = (Dali::VectorBase *)jarg1;
23440   {
23441     try {
23442       result = ((Dali::VectorBase const *)arg1)->Size();
23443     } catch (std::out_of_range& e) {
23444       {
23445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23446       };
23447     } catch (std::exception& e) {
23448       {
23449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23450       };
23451     } catch (Dali::DaliException e) {
23452       {
23453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23454       };
23455     } catch (...) {
23456       {
23457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23458       };
23459     }
23460   }
23461
23462   jresult = (unsigned long)result;
23463   return jresult;
23464 }
23465
23466
23467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23468   unsigned int jresult ;
23469   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23470   bool result;
23471
23472   arg1 = (Dali::VectorBase *)jarg1;
23473   {
23474     try {
23475       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23476     } catch (std::out_of_range& e) {
23477       {
23478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23479       };
23480     } catch (std::exception& e) {
23481       {
23482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23483       };
23484     } catch (Dali::DaliException e) {
23485       {
23486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23487       };
23488     } catch (...) {
23489       {
23490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23491       };
23492     }
23493   }
23494
23495   jresult = result;
23496   return jresult;
23497 }
23498
23499
23500 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23501   unsigned long jresult ;
23502   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23503   Dali::VectorBase::SizeType result;
23504
23505   arg1 = (Dali::VectorBase *)jarg1;
23506   {
23507     try {
23508       result = ((Dali::VectorBase const *)arg1)->Capacity();
23509     } catch (std::out_of_range& e) {
23510       {
23511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23512       };
23513     } catch (std::exception& e) {
23514       {
23515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23516       };
23517     } catch (Dali::DaliException e) {
23518       {
23519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23520       };
23521     } catch (...) {
23522       {
23523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23524       };
23525     }
23526   }
23527
23528   jresult = (unsigned long)result;
23529   return jresult;
23530 }
23531
23532
23533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23534   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23535
23536   arg1 = (Dali::VectorBase *)jarg1;
23537   {
23538     try {
23539       (arg1)->Release();
23540     } catch (std::out_of_range& e) {
23541       {
23542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23543       };
23544     } catch (std::exception& e) {
23545       {
23546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23547       };
23548     } catch (Dali::DaliException e) {
23549       {
23550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23551       };
23552     } catch (...) {
23553       {
23554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23555       };
23556     }
23557   }
23558
23559 }
23560
23561
23562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23563   void * jresult ;
23564   Dali::Image *result = 0 ;
23565
23566   {
23567     try {
23568       result = (Dali::Image *)new Dali::Image();
23569     } catch (std::out_of_range& e) {
23570       {
23571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23572       };
23573     } catch (std::exception& e) {
23574       {
23575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23576       };
23577     } catch (Dali::DaliException e) {
23578       {
23579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23580       };
23581     } catch (...) {
23582       {
23583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23584       };
23585     }
23586   }
23587
23588   jresult = (void *)result;
23589   return jresult;
23590 }
23591
23592
23593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23594   Dali::Image *arg1 = (Dali::Image *) 0 ;
23595
23596   arg1 = (Dali::Image *)jarg1;
23597   {
23598     try {
23599       delete arg1;
23600     } catch (std::out_of_range& e) {
23601       {
23602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23603       };
23604     } catch (std::exception& e) {
23605       {
23606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23607       };
23608     } catch (Dali::DaliException e) {
23609       {
23610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23611       };
23612     } catch (...) {
23613       {
23614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23615       };
23616     }
23617   }
23618
23619 }
23620
23621
23622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23623   void * jresult ;
23624   Dali::Image *arg1 = 0 ;
23625   Dali::Image *result = 0 ;
23626
23627   arg1 = (Dali::Image *)jarg1;
23628   if (!arg1) {
23629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23630     return 0;
23631   }
23632   {
23633     try {
23634       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23635     } catch (std::out_of_range& e) {
23636       {
23637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23638       };
23639     } catch (std::exception& e) {
23640       {
23641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23642       };
23643     } catch (Dali::DaliException e) {
23644       {
23645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23646       };
23647     } catch (...) {
23648       {
23649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23650       };
23651     }
23652   }
23653
23654   jresult = (void *)result;
23655   return jresult;
23656 }
23657
23658
23659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23660   void * jresult ;
23661   Dali::Image *arg1 = (Dali::Image *) 0 ;
23662   Dali::Image *arg2 = 0 ;
23663   Dali::Image *result = 0 ;
23664
23665   arg1 = (Dali::Image *)jarg1;
23666   arg2 = (Dali::Image *)jarg2;
23667   if (!arg2) {
23668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23669     return 0;
23670   }
23671   {
23672     try {
23673       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23674     } catch (std::out_of_range& e) {
23675       {
23676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23677       };
23678     } catch (std::exception& e) {
23679       {
23680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23681       };
23682     } catch (Dali::DaliException e) {
23683       {
23684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23685       };
23686     } catch (...) {
23687       {
23688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23689       };
23690     }
23691   }
23692
23693   jresult = (void *)result;
23694   return jresult;
23695 }
23696
23697
23698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23699   void * jresult ;
23700   Dali::BaseHandle arg1 ;
23701   Dali::BaseHandle *argp1 ;
23702   Dali::Image result;
23703
23704   argp1 = (Dali::BaseHandle *)jarg1;
23705   if (!argp1) {
23706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23707     return 0;
23708   }
23709   arg1 = *argp1;
23710   {
23711     try {
23712       result = Dali::Image::DownCast(arg1);
23713     } catch (std::out_of_range& e) {
23714       {
23715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23716       };
23717     } catch (std::exception& e) {
23718       {
23719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23720       };
23721     } catch (Dali::DaliException e) {
23722       {
23723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23724       };
23725     } catch (...) {
23726       {
23727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23728       };
23729     }
23730   }
23731
23732   jresult = new Dali::Image((const Dali::Image &)result);
23733   return jresult;
23734 }
23735
23736
23737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23738   unsigned int jresult ;
23739   Dali::Image *arg1 = (Dali::Image *) 0 ;
23740   unsigned int result;
23741
23742   arg1 = (Dali::Image *)jarg1;
23743   {
23744     try {
23745       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23746     } catch (std::out_of_range& e) {
23747       {
23748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23749       };
23750     } catch (std::exception& e) {
23751       {
23752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23753       };
23754     } catch (Dali::DaliException e) {
23755       {
23756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23757       };
23758     } catch (...) {
23759       {
23760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23761       };
23762     }
23763   }
23764
23765   jresult = result;
23766   return jresult;
23767 }
23768
23769
23770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23771   unsigned int jresult ;
23772   Dali::Image *arg1 = (Dali::Image *) 0 ;
23773   unsigned int result;
23774
23775   arg1 = (Dali::Image *)jarg1;
23776   {
23777     try {
23778       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23779     } catch (std::out_of_range& e) {
23780       {
23781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23782       };
23783     } catch (std::exception& e) {
23784       {
23785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23786       };
23787     } catch (Dali::DaliException e) {
23788       {
23789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23790       };
23791     } catch (...) {
23792       {
23793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23794       };
23795     }
23796   }
23797
23798   jresult = result;
23799   return jresult;
23800 }
23801
23802
23803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23804   void * jresult ;
23805   Dali::Image *arg1 = (Dali::Image *) 0 ;
23806   Dali::Image::ImageSignalType *result = 0 ;
23807
23808   arg1 = (Dali::Image *)jarg1;
23809   {
23810     try {
23811       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23812     } catch (std::out_of_range& e) {
23813       {
23814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23815       };
23816     } catch (std::exception& e) {
23817       {
23818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23819       };
23820     } catch (Dali::DaliException e) {
23821       {
23822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23823       };
23824     } catch (...) {
23825       {
23826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23827       };
23828     }
23829   }
23830
23831   jresult = (void *)result;
23832   return jresult;
23833 }
23834
23835
23836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23837   int jresult ;
23838   Dali::Pixel::Format result;
23839
23840   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23841   jresult = (int)result;
23842   return jresult;
23843 }
23844
23845
23846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23847   int jresult ;
23848   Dali::Pixel::Format result;
23849
23850   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23851   jresult = (int)result;
23852   return jresult;
23853 }
23854
23855
23856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23857   unsigned int jresult ;
23858   Dali::Pixel::Format arg1 ;
23859   bool result;
23860
23861   arg1 = (Dali::Pixel::Format)jarg1;
23862   {
23863     try {
23864       result = (bool)Dali::Pixel::HasAlpha(arg1);
23865     } catch (std::out_of_range& e) {
23866       {
23867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23868       };
23869     } catch (std::exception& e) {
23870       {
23871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23872       };
23873     } catch (Dali::DaliException e) {
23874       {
23875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23876       };
23877     } catch (...) {
23878       {
23879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23880       };
23881     }
23882   }
23883
23884   jresult = result;
23885   return jresult;
23886 }
23887
23888
23889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23890   unsigned int jresult ;
23891   Dali::Pixel::Format arg1 ;
23892   unsigned int result;
23893
23894   arg1 = (Dali::Pixel::Format)jarg1;
23895   {
23896     try {
23897       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23898     } catch (std::out_of_range& e) {
23899       {
23900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23901       };
23902     } catch (std::exception& e) {
23903       {
23904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23905       };
23906     } catch (Dali::DaliException e) {
23907       {
23908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23909       };
23910     } catch (...) {
23911       {
23912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23913       };
23914     }
23915   }
23916
23917   jresult = result;
23918   return jresult;
23919 }
23920
23921
23922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23923   Dali::Pixel::Format arg1 ;
23924   int *arg2 = 0 ;
23925   int *arg3 = 0 ;
23926
23927   arg1 = (Dali::Pixel::Format)jarg1;
23928   arg2 = (int *)jarg2;
23929   if (!arg2) {
23930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23931     return ;
23932   }
23933   arg3 = (int *)jarg3;
23934   if (!arg3) {
23935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23936     return ;
23937   }
23938   {
23939     try {
23940       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23941     } catch (std::out_of_range& e) {
23942       {
23943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23944       };
23945     } catch (std::exception& e) {
23946       {
23947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23948       };
23949     } catch (Dali::DaliException e) {
23950       {
23951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23952       };
23953     } catch (...) {
23954       {
23955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23956       };
23957     }
23958   }
23959
23960 }
23961
23962
23963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23964   void * jresult ;
23965   unsigned char *arg1 = (unsigned char *) 0 ;
23966   unsigned int arg2 ;
23967   unsigned int arg3 ;
23968   unsigned int arg4 ;
23969   Dali::Pixel::Format arg5 ;
23970   Dali::PixelData::ReleaseFunction arg6 ;
23971   Dali::PixelData result;
23972
23973   arg1 = jarg1;
23974   arg2 = (unsigned int)jarg2;
23975   arg3 = (unsigned int)jarg3;
23976   arg4 = (unsigned int)jarg4;
23977   arg5 = (Dali::Pixel::Format)jarg5;
23978   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23979   {
23980     try {
23981       auto pixelBuffer = new unsigned char[jarg2];
23982       memcpy( pixelBuffer, arg1, arg2);
23983       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23984     } catch (std::out_of_range& e) {
23985       {
23986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23987       };
23988     } catch (std::exception& e) {
23989       {
23990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23991       };
23992     } catch (Dali::DaliException e) {
23993       {
23994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23995       };
23996     } catch (...) {
23997       {
23998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23999       };
24000     }
24001   }
24002
24003   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24004
24005
24006   return jresult;
24007 }
24008
24009
24010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24011   void * jresult ;
24012   Dali::PixelData *result = 0 ;
24013
24014   {
24015     try {
24016       result = (Dali::PixelData *)new Dali::PixelData();
24017     } catch (std::out_of_range& e) {
24018       {
24019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24020       };
24021     } catch (std::exception& e) {
24022       {
24023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24024       };
24025     } catch (Dali::DaliException e) {
24026       {
24027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24028       };
24029     } catch (...) {
24030       {
24031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24032       };
24033     }
24034   }
24035
24036   jresult = (void *)result;
24037   return jresult;
24038 }
24039
24040
24041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24042   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24043
24044   arg1 = (Dali::PixelData *)jarg1;
24045   {
24046     try {
24047       delete arg1;
24048     } catch (std::out_of_range& e) {
24049       {
24050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24051       };
24052     } catch (std::exception& e) {
24053       {
24054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24055       };
24056     } catch (Dali::DaliException e) {
24057       {
24058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24059       };
24060     } catch (...) {
24061       {
24062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24063       };
24064     }
24065   }
24066
24067 }
24068
24069
24070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24071   void * jresult ;
24072   Dali::PixelData *arg1 = 0 ;
24073   Dali::PixelData *result = 0 ;
24074
24075   arg1 = (Dali::PixelData *)jarg1;
24076   if (!arg1) {
24077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24078     return 0;
24079   }
24080   {
24081     try {
24082       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24083     } catch (std::out_of_range& e) {
24084       {
24085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24086       };
24087     } catch (std::exception& e) {
24088       {
24089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24090       };
24091     } catch (Dali::DaliException e) {
24092       {
24093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24094       };
24095     } catch (...) {
24096       {
24097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24098       };
24099     }
24100   }
24101
24102   jresult = (void *)result;
24103   return jresult;
24104 }
24105
24106
24107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24108   void * jresult ;
24109   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24110   Dali::PixelData *arg2 = 0 ;
24111   Dali::PixelData *result = 0 ;
24112
24113   arg1 = (Dali::PixelData *)jarg1;
24114   arg2 = (Dali::PixelData *)jarg2;
24115   if (!arg2) {
24116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24117     return 0;
24118   }
24119   {
24120     try {
24121       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24122     } catch (std::out_of_range& e) {
24123       {
24124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24125       };
24126     } catch (std::exception& e) {
24127       {
24128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24129       };
24130     } catch (Dali::DaliException e) {
24131       {
24132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24133       };
24134     } catch (...) {
24135       {
24136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24137       };
24138     }
24139   }
24140
24141   jresult = (void *)result;
24142   return jresult;
24143 }
24144
24145
24146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24147   unsigned int jresult ;
24148   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24149   unsigned int result;
24150
24151   arg1 = (Dali::PixelData *)jarg1;
24152   {
24153     try {
24154       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24155     } catch (std::out_of_range& e) {
24156       {
24157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24158       };
24159     } catch (std::exception& e) {
24160       {
24161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24162       };
24163     } catch (Dali::DaliException e) {
24164       {
24165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24166       };
24167     } catch (...) {
24168       {
24169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24170       };
24171     }
24172   }
24173
24174   jresult = result;
24175   return jresult;
24176 }
24177
24178
24179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24180   unsigned int jresult ;
24181   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24182   unsigned int result;
24183
24184   arg1 = (Dali::PixelData *)jarg1;
24185   {
24186     try {
24187       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24188     } catch (std::out_of_range& e) {
24189       {
24190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24191       };
24192     } catch (std::exception& e) {
24193       {
24194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24195       };
24196     } catch (Dali::DaliException e) {
24197       {
24198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24199       };
24200     } catch (...) {
24201       {
24202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24203       };
24204     }
24205   }
24206
24207   jresult = result;
24208   return jresult;
24209 }
24210
24211
24212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24213   int jresult ;
24214   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24215   Dali::Pixel::Format result;
24216
24217   arg1 = (Dali::PixelData *)jarg1;
24218   {
24219     try {
24220       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24221     } catch (std::out_of_range& e) {
24222       {
24223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24224       };
24225     } catch (std::exception& e) {
24226       {
24227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24228       };
24229     } catch (Dali::DaliException e) {
24230       {
24231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24232       };
24233     } catch (...) {
24234       {
24235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24236       };
24237     }
24238   }
24239
24240   jresult = (int)result;
24241   return jresult;
24242 }
24243
24244
24245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24246   unsigned int jresult ;
24247   unsigned int result;
24248
24249   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24250   jresult = result;
24251   return jresult;
24252 }
24253
24254
24255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24256   unsigned int jresult ;
24257   unsigned int result;
24258
24259   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24260   jresult = result;
24261   return jresult;
24262 }
24263
24264
24265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24266   unsigned int jresult ;
24267   unsigned int result;
24268
24269   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24270   jresult = result;
24271   return jresult;
24272 }
24273
24274
24275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24276   unsigned int jresult ;
24277   unsigned int result;
24278
24279   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24280   jresult = result;
24281   return jresult;
24282 }
24283
24284
24285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24286   unsigned int jresult ;
24287   unsigned int result;
24288
24289   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24290   jresult = result;
24291   return jresult;
24292 }
24293
24294
24295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24296   unsigned int jresult ;
24297   unsigned int result;
24298
24299   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24300   jresult = result;
24301   return jresult;
24302 }
24303
24304
24305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24306   void * jresult ;
24307   Dali::TextureType::Type arg1 ;
24308   Dali::Pixel::Format arg2 ;
24309   unsigned int arg3 ;
24310   unsigned int arg4 ;
24311   Dali::Texture result;
24312
24313   arg1 = (Dali::TextureType::Type)jarg1;
24314   arg2 = (Dali::Pixel::Format)jarg2;
24315   arg3 = (unsigned int)jarg3;
24316   arg4 = (unsigned int)jarg4;
24317   {
24318     try {
24319       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24320     } catch (std::out_of_range& e) {
24321       {
24322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24323       };
24324     } catch (std::exception& e) {
24325       {
24326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24327       };
24328     } catch (Dali::DaliException e) {
24329       {
24330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24331       };
24332     } catch (...) {
24333       {
24334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24335       };
24336     }
24337   }
24338
24339   jresult = new Dali::Texture((const Dali::Texture &)result);
24340   return jresult;
24341 }
24342
24343
24344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24345   void * jresult ;
24346   NativeImageInterface *arg1 = 0 ;
24347   Dali::Texture result;
24348
24349   arg1 = (NativeImageInterface *)jarg1;
24350   if (!arg1) {
24351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24352     return 0;
24353   }
24354   {
24355     try {
24356       result = Dali::Texture::New(*arg1);
24357     } catch (std::out_of_range& e) {
24358       {
24359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24360       };
24361     } catch (std::exception& e) {
24362       {
24363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24364       };
24365     } catch (Dali::DaliException e) {
24366       {
24367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24368       };
24369     } catch (...) {
24370       {
24371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24372       };
24373     }
24374   }
24375
24376   jresult = new Dali::Texture((const Dali::Texture &)result);
24377   return jresult;
24378 }
24379
24380
24381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24382   void * jresult ;
24383   Dali::Texture *result = 0 ;
24384
24385   {
24386     try {
24387       result = (Dali::Texture *)new Dali::Texture();
24388     } catch (std::out_of_range& e) {
24389       {
24390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24391       };
24392     } catch (std::exception& e) {
24393       {
24394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24395       };
24396     } catch (Dali::DaliException e) {
24397       {
24398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24399       };
24400     } catch (...) {
24401       {
24402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24403       };
24404     }
24405   }
24406
24407   jresult = (void *)result;
24408   return jresult;
24409 }
24410
24411
24412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24413   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24414
24415   arg1 = (Dali::Texture *)jarg1;
24416   {
24417     try {
24418       delete arg1;
24419     } catch (std::out_of_range& e) {
24420       {
24421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24422       };
24423     } catch (std::exception& e) {
24424       {
24425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24426       };
24427     } catch (Dali::DaliException e) {
24428       {
24429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24430       };
24431     } catch (...) {
24432       {
24433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24434       };
24435     }
24436   }
24437
24438 }
24439
24440
24441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24442   void * jresult ;
24443   Dali::Texture *arg1 = 0 ;
24444   Dali::Texture *result = 0 ;
24445
24446   arg1 = (Dali::Texture *)jarg1;
24447   if (!arg1) {
24448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24449     return 0;
24450   }
24451   {
24452     try {
24453       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24454     } catch (std::out_of_range& e) {
24455       {
24456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24457       };
24458     } catch (std::exception& e) {
24459       {
24460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24461       };
24462     } catch (Dali::DaliException e) {
24463       {
24464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24465       };
24466     } catch (...) {
24467       {
24468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24469       };
24470     }
24471   }
24472
24473   jresult = (void *)result;
24474   return jresult;
24475 }
24476
24477
24478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24479   void * jresult ;
24480   Dali::BaseHandle arg1 ;
24481   Dali::BaseHandle *argp1 ;
24482   Dali::Texture result;
24483
24484   argp1 = (Dali::BaseHandle *)jarg1;
24485   if (!argp1) {
24486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24487     return 0;
24488   }
24489   arg1 = *argp1;
24490   {
24491     try {
24492       result = Dali::Texture::DownCast(arg1);
24493     } catch (std::out_of_range& e) {
24494       {
24495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24496       };
24497     } catch (std::exception& e) {
24498       {
24499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24500       };
24501     } catch (Dali::DaliException e) {
24502       {
24503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24504       };
24505     } catch (...) {
24506       {
24507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24508       };
24509     }
24510   }
24511
24512   jresult = new Dali::Texture((const Dali::Texture &)result);
24513   return jresult;
24514 }
24515
24516
24517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24518   void * jresult ;
24519   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24520   Dali::Texture *arg2 = 0 ;
24521   Dali::Texture *result = 0 ;
24522
24523   arg1 = (Dali::Texture *)jarg1;
24524   arg2 = (Dali::Texture *)jarg2;
24525   if (!arg2) {
24526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24527     return 0;
24528   }
24529   {
24530     try {
24531       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24532     } catch (std::out_of_range& e) {
24533       {
24534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24535       };
24536     } catch (std::exception& e) {
24537       {
24538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24539       };
24540     } catch (Dali::DaliException e) {
24541       {
24542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24543       };
24544     } catch (...) {
24545       {
24546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24547       };
24548     }
24549   }
24550
24551   jresult = (void *)result;
24552   return jresult;
24553 }
24554
24555
24556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24557   unsigned int jresult ;
24558   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24559   Dali::PixelData arg2 ;
24560   Dali::PixelData *argp2 ;
24561   bool result;
24562
24563   arg1 = (Dali::Texture *)jarg1;
24564   argp2 = (Dali::PixelData *)jarg2;
24565   if (!argp2) {
24566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24567     return 0;
24568   }
24569   arg2 = *argp2;
24570   {
24571     try {
24572       result = (bool)(arg1)->Upload(arg2);
24573     } catch (std::out_of_range& e) {
24574       {
24575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24576       };
24577     } catch (std::exception& e) {
24578       {
24579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24580       };
24581     } catch (Dali::DaliException e) {
24582       {
24583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24584       };
24585     } catch (...) {
24586       {
24587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24588       };
24589     }
24590   }
24591
24592   jresult = result;
24593   return jresult;
24594 }
24595
24596
24597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) {
24598   unsigned int jresult ;
24599   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24600   Dali::PixelData arg2 ;
24601   unsigned int arg3 ;
24602   unsigned int arg4 ;
24603   unsigned int arg5 ;
24604   unsigned int arg6 ;
24605   unsigned int arg7 ;
24606   unsigned int arg8 ;
24607   Dali::PixelData *argp2 ;
24608   bool result;
24609
24610   arg1 = (Dali::Texture *)jarg1;
24611   argp2 = (Dali::PixelData *)jarg2;
24612   if (!argp2) {
24613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24614     return 0;
24615   }
24616   arg2 = *argp2;
24617   arg3 = (unsigned int)jarg3;
24618   arg4 = (unsigned int)jarg4;
24619   arg5 = (unsigned int)jarg5;
24620   arg6 = (unsigned int)jarg6;
24621   arg7 = (unsigned int)jarg7;
24622   arg8 = (unsigned int)jarg8;
24623   {
24624     try {
24625       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24626     } catch (std::out_of_range& e) {
24627       {
24628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24629       };
24630     } catch (std::exception& e) {
24631       {
24632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24633       };
24634     } catch (Dali::DaliException e) {
24635       {
24636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24637       };
24638     } catch (...) {
24639       {
24640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24641       };
24642     }
24643   }
24644
24645   jresult = result;
24646   return jresult;
24647 }
24648
24649
24650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24651   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24652
24653   arg1 = (Dali::Texture *)jarg1;
24654   {
24655     try {
24656       (arg1)->GenerateMipmaps();
24657     } catch (std::out_of_range& e) {
24658       {
24659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24660       };
24661     } catch (std::exception& e) {
24662       {
24663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24664       };
24665     } catch (Dali::DaliException e) {
24666       {
24667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24668       };
24669     } catch (...) {
24670       {
24671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24672       };
24673     }
24674   }
24675
24676 }
24677
24678
24679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24680   unsigned int jresult ;
24681   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24682   unsigned int result;
24683
24684   arg1 = (Dali::Texture *)jarg1;
24685   {
24686     try {
24687       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24688     } catch (std::out_of_range& e) {
24689       {
24690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24691       };
24692     } catch (std::exception& e) {
24693       {
24694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24695       };
24696     } catch (Dali::DaliException e) {
24697       {
24698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24699       };
24700     } catch (...) {
24701       {
24702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24703       };
24704     }
24705   }
24706
24707   jresult = result;
24708   return jresult;
24709 }
24710
24711
24712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24713   unsigned int jresult ;
24714   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24715   unsigned int result;
24716
24717   arg1 = (Dali::Texture *)jarg1;
24718   {
24719     try {
24720       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24721     } catch (std::out_of_range& e) {
24722       {
24723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24724       };
24725     } catch (std::exception& e) {
24726       {
24727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24728       };
24729     } catch (Dali::DaliException e) {
24730       {
24731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24732       };
24733     } catch (...) {
24734       {
24735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24736       };
24737     }
24738   }
24739
24740   jresult = result;
24741   return jresult;
24742 }
24743
24744
24745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24746   void * jresult ;
24747   Dali::Sampler result;
24748
24749   {
24750     try {
24751       result = Dali::Sampler::New();
24752     } catch (std::out_of_range& e) {
24753       {
24754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24755       };
24756     } catch (std::exception& e) {
24757       {
24758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24759       };
24760     } catch (Dali::DaliException e) {
24761       {
24762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24763       };
24764     } catch (...) {
24765       {
24766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24767       };
24768     }
24769   }
24770
24771   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24772   return jresult;
24773 }
24774
24775
24776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24777   void * jresult ;
24778   Dali::Sampler *result = 0 ;
24779
24780   {
24781     try {
24782       result = (Dali::Sampler *)new Dali::Sampler();
24783     } catch (std::out_of_range& e) {
24784       {
24785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24786       };
24787     } catch (std::exception& e) {
24788       {
24789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24790       };
24791     } catch (Dali::DaliException e) {
24792       {
24793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24794       };
24795     } catch (...) {
24796       {
24797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24798       };
24799     }
24800   }
24801
24802   jresult = (void *)result;
24803   return jresult;
24804 }
24805
24806
24807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24808   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24809
24810   arg1 = (Dali::Sampler *)jarg1;
24811   {
24812     try {
24813       delete arg1;
24814     } catch (std::out_of_range& e) {
24815       {
24816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24817       };
24818     } catch (std::exception& e) {
24819       {
24820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24821       };
24822     } catch (Dali::DaliException e) {
24823       {
24824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24825       };
24826     } catch (...) {
24827       {
24828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24829       };
24830     }
24831   }
24832
24833 }
24834
24835
24836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24837   void * jresult ;
24838   Dali::Sampler *arg1 = 0 ;
24839   Dali::Sampler *result = 0 ;
24840
24841   arg1 = (Dali::Sampler *)jarg1;
24842   if (!arg1) {
24843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24844     return 0;
24845   }
24846   {
24847     try {
24848       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24849     } catch (std::out_of_range& e) {
24850       {
24851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24852       };
24853     } catch (std::exception& e) {
24854       {
24855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24856       };
24857     } catch (Dali::DaliException e) {
24858       {
24859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24860       };
24861     } catch (...) {
24862       {
24863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24864       };
24865     }
24866   }
24867
24868   jresult = (void *)result;
24869   return jresult;
24870 }
24871
24872
24873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24874   void * jresult ;
24875   Dali::BaseHandle arg1 ;
24876   Dali::BaseHandle *argp1 ;
24877   Dali::Sampler result;
24878
24879   argp1 = (Dali::BaseHandle *)jarg1;
24880   if (!argp1) {
24881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24882     return 0;
24883   }
24884   arg1 = *argp1;
24885   {
24886     try {
24887       result = Dali::Sampler::DownCast(arg1);
24888     } catch (std::out_of_range& e) {
24889       {
24890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24891       };
24892     } catch (std::exception& e) {
24893       {
24894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24895       };
24896     } catch (Dali::DaliException e) {
24897       {
24898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24899       };
24900     } catch (...) {
24901       {
24902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24903       };
24904     }
24905   }
24906
24907   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24908   return jresult;
24909 }
24910
24911
24912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24913   void * jresult ;
24914   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24915   Dali::Sampler *arg2 = 0 ;
24916   Dali::Sampler *result = 0 ;
24917
24918   arg1 = (Dali::Sampler *)jarg1;
24919   arg2 = (Dali::Sampler *)jarg2;
24920   if (!arg2) {
24921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24922     return 0;
24923   }
24924   {
24925     try {
24926       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24927     } catch (std::out_of_range& e) {
24928       {
24929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24930       };
24931     } catch (std::exception& e) {
24932       {
24933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24934       };
24935     } catch (Dali::DaliException e) {
24936       {
24937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24938       };
24939     } catch (...) {
24940       {
24941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24942       };
24943     }
24944   }
24945
24946   jresult = (void *)result;
24947   return jresult;
24948 }
24949
24950
24951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24952   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24953   Dali::FilterMode::Type arg2 ;
24954   Dali::FilterMode::Type arg3 ;
24955
24956   arg1 = (Dali::Sampler *)jarg1;
24957   arg2 = (Dali::FilterMode::Type)jarg2;
24958   arg3 = (Dali::FilterMode::Type)jarg3;
24959   {
24960     try {
24961       (arg1)->SetFilterMode(arg2,arg3);
24962     } catch (std::out_of_range& e) {
24963       {
24964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24965       };
24966     } catch (std::exception& e) {
24967       {
24968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24969       };
24970     } catch (Dali::DaliException e) {
24971       {
24972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24973       };
24974     } catch (...) {
24975       {
24976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24977       };
24978     }
24979   }
24980
24981 }
24982
24983
24984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24985   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24986   Dali::WrapMode::Type arg2 ;
24987   Dali::WrapMode::Type arg3 ;
24988
24989   arg1 = (Dali::Sampler *)jarg1;
24990   arg2 = (Dali::WrapMode::Type)jarg2;
24991   arg3 = (Dali::WrapMode::Type)jarg3;
24992   {
24993     try {
24994       (arg1)->SetWrapMode(arg2,arg3);
24995     } catch (std::out_of_range& e) {
24996       {
24997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24998       };
24999     } catch (std::exception& e) {
25000       {
25001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25002       };
25003     } catch (Dali::DaliException e) {
25004       {
25005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25006       };
25007     } catch (...) {
25008       {
25009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25010       };
25011     }
25012   }
25013
25014 }
25015
25016
25017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25018   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25019   Dali::WrapMode::Type arg2 ;
25020   Dali::WrapMode::Type arg3 ;
25021   Dali::WrapMode::Type arg4 ;
25022
25023   arg1 = (Dali::Sampler *)jarg1;
25024   arg2 = (Dali::WrapMode::Type)jarg2;
25025   arg3 = (Dali::WrapMode::Type)jarg3;
25026   arg4 = (Dali::WrapMode::Type)jarg4;
25027   {
25028     try {
25029       (arg1)->SetWrapMode(arg2,arg3,arg4);
25030     } catch (std::out_of_range& e) {
25031       {
25032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25033       };
25034     } catch (std::exception& e) {
25035       {
25036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25037       };
25038     } catch (Dali::DaliException e) {
25039       {
25040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25041       };
25042     } catch (...) {
25043       {
25044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25045       };
25046     }
25047   }
25048
25049 }
25050
25051
25052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25053   void * jresult ;
25054   Dali::TextureSet result;
25055
25056   {
25057     try {
25058       result = Dali::TextureSet::New();
25059     } catch (std::out_of_range& e) {
25060       {
25061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25062       };
25063     } catch (std::exception& e) {
25064       {
25065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25066       };
25067     } catch (Dali::DaliException e) {
25068       {
25069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25070       };
25071     } catch (...) {
25072       {
25073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25074       };
25075     }
25076   }
25077
25078   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25079   return jresult;
25080 }
25081
25082
25083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25084   void * jresult ;
25085   Dali::TextureSet *result = 0 ;
25086
25087   {
25088     try {
25089       result = (Dali::TextureSet *)new Dali::TextureSet();
25090     } catch (std::out_of_range& e) {
25091       {
25092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25093       };
25094     } catch (std::exception& e) {
25095       {
25096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25097       };
25098     } catch (Dali::DaliException e) {
25099       {
25100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25101       };
25102     } catch (...) {
25103       {
25104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25105       };
25106     }
25107   }
25108
25109   jresult = (void *)result;
25110   return jresult;
25111 }
25112
25113
25114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25115   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25116
25117   arg1 = (Dali::TextureSet *)jarg1;
25118   {
25119     try {
25120       delete arg1;
25121     } catch (std::out_of_range& e) {
25122       {
25123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25124       };
25125     } catch (std::exception& e) {
25126       {
25127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25128       };
25129     } catch (Dali::DaliException e) {
25130       {
25131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25132       };
25133     } catch (...) {
25134       {
25135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25136       };
25137     }
25138   }
25139
25140 }
25141
25142
25143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25144   void * jresult ;
25145   Dali::TextureSet *arg1 = 0 ;
25146   Dali::TextureSet *result = 0 ;
25147
25148   arg1 = (Dali::TextureSet *)jarg1;
25149   if (!arg1) {
25150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25151     return 0;
25152   }
25153   {
25154     try {
25155       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25156     } catch (std::out_of_range& e) {
25157       {
25158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25159       };
25160     } catch (std::exception& e) {
25161       {
25162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25163       };
25164     } catch (Dali::DaliException e) {
25165       {
25166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25167       };
25168     } catch (...) {
25169       {
25170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25171       };
25172     }
25173   }
25174
25175   jresult = (void *)result;
25176   return jresult;
25177 }
25178
25179
25180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25181   void * jresult ;
25182   Dali::BaseHandle arg1 ;
25183   Dali::BaseHandle *argp1 ;
25184   Dali::TextureSet result;
25185
25186   argp1 = (Dali::BaseHandle *)jarg1;
25187   if (!argp1) {
25188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25189     return 0;
25190   }
25191   arg1 = *argp1;
25192   {
25193     try {
25194       result = Dali::TextureSet::DownCast(arg1);
25195     } catch (std::out_of_range& e) {
25196       {
25197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25198       };
25199     } catch (std::exception& e) {
25200       {
25201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25202       };
25203     } catch (Dali::DaliException e) {
25204       {
25205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25206       };
25207     } catch (...) {
25208       {
25209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25210       };
25211     }
25212   }
25213
25214   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25215   return jresult;
25216 }
25217
25218
25219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25220   void * jresult ;
25221   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25222   Dali::TextureSet *arg2 = 0 ;
25223   Dali::TextureSet *result = 0 ;
25224
25225   arg1 = (Dali::TextureSet *)jarg1;
25226   arg2 = (Dali::TextureSet *)jarg2;
25227   if (!arg2) {
25228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25229     return 0;
25230   }
25231   {
25232     try {
25233       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25234     } catch (std::out_of_range& e) {
25235       {
25236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25237       };
25238     } catch (std::exception& e) {
25239       {
25240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25241       };
25242     } catch (Dali::DaliException e) {
25243       {
25244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25245       };
25246     } catch (...) {
25247       {
25248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25249       };
25250     }
25251   }
25252
25253   jresult = (void *)result;
25254   return jresult;
25255 }
25256
25257
25258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25259   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25260   size_t arg2 ;
25261   Dali::Texture arg3 ;
25262   Dali::Texture *argp3 ;
25263
25264   arg1 = (Dali::TextureSet *)jarg1;
25265   arg2 = (size_t)jarg2;
25266   argp3 = (Dali::Texture *)jarg3;
25267   if (!argp3) {
25268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25269     return ;
25270   }
25271   arg3 = *argp3;
25272   {
25273     try {
25274       (arg1)->SetTexture(arg2,arg3);
25275     } catch (std::out_of_range& e) {
25276       {
25277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25278       };
25279     } catch (std::exception& e) {
25280       {
25281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25282       };
25283     } catch (Dali::DaliException e) {
25284       {
25285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25286       };
25287     } catch (...) {
25288       {
25289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25290       };
25291     }
25292   }
25293
25294 }
25295
25296
25297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25298   void * jresult ;
25299   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25300   size_t arg2 ;
25301   Dali::Texture result;
25302
25303   arg1 = (Dali::TextureSet *)jarg1;
25304   arg2 = (size_t)jarg2;
25305   {
25306     try {
25307       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25308     } catch (std::out_of_range& e) {
25309       {
25310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25311       };
25312     } catch (std::exception& e) {
25313       {
25314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25315       };
25316     } catch (Dali::DaliException e) {
25317       {
25318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25319       };
25320     } catch (...) {
25321       {
25322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25323       };
25324     }
25325   }
25326
25327   jresult = new Dali::Texture((const Dali::Texture &)result);
25328   return jresult;
25329 }
25330
25331
25332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25333   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25334   size_t arg2 ;
25335   Dali::Sampler arg3 ;
25336   Dali::Sampler *argp3 ;
25337
25338   arg1 = (Dali::TextureSet *)jarg1;
25339   arg2 = (size_t)jarg2;
25340   argp3 = (Dali::Sampler *)jarg3;
25341   if (!argp3) {
25342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25343     return ;
25344   }
25345   arg3 = *argp3;
25346   {
25347     try {
25348       (arg1)->SetSampler(arg2,arg3);
25349     } catch (std::out_of_range& e) {
25350       {
25351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25352       };
25353     } catch (std::exception& e) {
25354       {
25355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25356       };
25357     } catch (Dali::DaliException e) {
25358       {
25359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25360       };
25361     } catch (...) {
25362       {
25363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25364       };
25365     }
25366   }
25367
25368 }
25369
25370
25371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25372   void * jresult ;
25373   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25374   size_t arg2 ;
25375   Dali::Sampler result;
25376
25377   arg1 = (Dali::TextureSet *)jarg1;
25378   arg2 = (size_t)jarg2;
25379   {
25380     try {
25381       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25382     } catch (std::out_of_range& e) {
25383       {
25384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25385       };
25386     } catch (std::exception& e) {
25387       {
25388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25389       };
25390     } catch (Dali::DaliException e) {
25391       {
25392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25393       };
25394     } catch (...) {
25395       {
25396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25397       };
25398     }
25399   }
25400
25401   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25402   return jresult;
25403 }
25404
25405
25406 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25407   unsigned long jresult ;
25408   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25409   size_t result;
25410
25411   arg1 = (Dali::TextureSet *)jarg1;
25412   {
25413     try {
25414       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25415     } catch (std::out_of_range& e) {
25416       {
25417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25418       };
25419     } catch (std::exception& e) {
25420       {
25421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25422       };
25423     } catch (Dali::DaliException e) {
25424       {
25425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25426       };
25427     } catch (...) {
25428       {
25429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25430       };
25431     }
25432   }
25433
25434   jresult = (unsigned long)result;
25435   return jresult;
25436 }
25437
25438
25439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25440   void * jresult ;
25441   Dali::Property::Map *arg1 = 0 ;
25442   Dali::PropertyBuffer result;
25443
25444   arg1 = (Dali::Property::Map *)jarg1;
25445   if (!arg1) {
25446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25447     return 0;
25448   }
25449   {
25450     try {
25451       result = Dali::PropertyBuffer::New(*arg1);
25452     } catch (std::out_of_range& e) {
25453       {
25454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25455       };
25456     } catch (std::exception& e) {
25457       {
25458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25459       };
25460     } catch (Dali::DaliException e) {
25461       {
25462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25463       };
25464     } catch (...) {
25465       {
25466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25467       };
25468     }
25469   }
25470
25471   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25472   return jresult;
25473 }
25474
25475
25476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25477   void * jresult ;
25478   Dali::PropertyBuffer *result = 0 ;
25479
25480   {
25481     try {
25482       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25483     } catch (std::out_of_range& e) {
25484       {
25485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25486       };
25487     } catch (std::exception& e) {
25488       {
25489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25490       };
25491     } catch (Dali::DaliException e) {
25492       {
25493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25494       };
25495     } catch (...) {
25496       {
25497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25498       };
25499     }
25500   }
25501
25502   jresult = (void *)result;
25503   return jresult;
25504 }
25505
25506
25507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25508   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25509
25510   arg1 = (Dali::PropertyBuffer *)jarg1;
25511   {
25512     try {
25513       delete arg1;
25514     } catch (std::out_of_range& e) {
25515       {
25516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25517       };
25518     } catch (std::exception& e) {
25519       {
25520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25521       };
25522     } catch (Dali::DaliException e) {
25523       {
25524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25525       };
25526     } catch (...) {
25527       {
25528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25529       };
25530     }
25531   }
25532
25533 }
25534
25535
25536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25537   void * jresult ;
25538   Dali::PropertyBuffer *arg1 = 0 ;
25539   Dali::PropertyBuffer *result = 0 ;
25540
25541   arg1 = (Dali::PropertyBuffer *)jarg1;
25542   if (!arg1) {
25543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25544     return 0;
25545   }
25546   {
25547     try {
25548       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25549     } catch (std::out_of_range& e) {
25550       {
25551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25552       };
25553     } catch (std::exception& e) {
25554       {
25555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25556       };
25557     } catch (Dali::DaliException e) {
25558       {
25559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25560       };
25561     } catch (...) {
25562       {
25563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25564       };
25565     }
25566   }
25567
25568   jresult = (void *)result;
25569   return jresult;
25570 }
25571
25572
25573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25574   void * jresult ;
25575   Dali::BaseHandle arg1 ;
25576   Dali::BaseHandle *argp1 ;
25577   Dali::PropertyBuffer result;
25578
25579   argp1 = (Dali::BaseHandle *)jarg1;
25580   if (!argp1) {
25581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25582     return 0;
25583   }
25584   arg1 = *argp1;
25585   {
25586     try {
25587       result = Dali::PropertyBuffer::DownCast(arg1);
25588     } catch (std::out_of_range& e) {
25589       {
25590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25591       };
25592     } catch (std::exception& e) {
25593       {
25594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25595       };
25596     } catch (Dali::DaliException e) {
25597       {
25598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25599       };
25600     } catch (...) {
25601       {
25602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25603       };
25604     }
25605   }
25606
25607   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25608   return jresult;
25609 }
25610
25611
25612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25613   void * jresult ;
25614   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25615   Dali::PropertyBuffer *arg2 = 0 ;
25616   Dali::PropertyBuffer *result = 0 ;
25617
25618   arg1 = (Dali::PropertyBuffer *)jarg1;
25619   arg2 = (Dali::PropertyBuffer *)jarg2;
25620   if (!arg2) {
25621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25622     return 0;
25623   }
25624   {
25625     try {
25626       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25627     } catch (std::out_of_range& e) {
25628       {
25629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25630       };
25631     } catch (std::exception& e) {
25632       {
25633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25634       };
25635     } catch (Dali::DaliException e) {
25636       {
25637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25638       };
25639     } catch (...) {
25640       {
25641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25642       };
25643     }
25644   }
25645
25646   jresult = (void *)result;
25647   return jresult;
25648 }
25649
25650
25651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25652   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25653   void *arg2 = (void *) 0 ;
25654   std::size_t arg3 ;
25655
25656   arg1 = (Dali::PropertyBuffer *)jarg1;
25657   arg2 = jarg2;
25658   arg3 = (std::size_t)jarg3;
25659   {
25660     try {
25661       (arg1)->SetData((void const *)arg2,arg3);
25662     } catch (std::out_of_range& e) {
25663       {
25664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25665       };
25666     } catch (std::exception& e) {
25667       {
25668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25669       };
25670     } catch (Dali::DaliException e) {
25671       {
25672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25673       };
25674     } catch (...) {
25675       {
25676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25677       };
25678     }
25679   }
25680
25681 }
25682
25683
25684 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25685   unsigned long jresult ;
25686   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25687   std::size_t result;
25688
25689   arg1 = (Dali::PropertyBuffer *)jarg1;
25690   {
25691     try {
25692       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25693     } catch (std::out_of_range& e) {
25694       {
25695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25696       };
25697     } catch (std::exception& e) {
25698       {
25699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25700       };
25701     } catch (Dali::DaliException e) {
25702       {
25703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25704       };
25705     } catch (...) {
25706       {
25707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25708       };
25709     }
25710   }
25711
25712   jresult = (unsigned long)result;
25713   return jresult;
25714 }
25715
25716
25717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25718   void * jresult ;
25719   Dali::Geometry result;
25720
25721   {
25722     try {
25723       result = Dali::Geometry::New();
25724     } catch (std::out_of_range& e) {
25725       {
25726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25727       };
25728     } catch (std::exception& e) {
25729       {
25730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25731       };
25732     } catch (Dali::DaliException e) {
25733       {
25734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25735       };
25736     } catch (...) {
25737       {
25738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25739       };
25740     }
25741   }
25742
25743   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25744   return jresult;
25745 }
25746
25747
25748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25749   void * jresult ;
25750   Dali::Geometry *result = 0 ;
25751
25752   {
25753     try {
25754       result = (Dali::Geometry *)new Dali::Geometry();
25755     } catch (std::out_of_range& e) {
25756       {
25757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25758       };
25759     } catch (std::exception& e) {
25760       {
25761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25762       };
25763     } catch (Dali::DaliException e) {
25764       {
25765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25766       };
25767     } catch (...) {
25768       {
25769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25770       };
25771     }
25772   }
25773
25774   jresult = (void *)result;
25775   return jresult;
25776 }
25777
25778
25779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25780   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25781
25782   arg1 = (Dali::Geometry *)jarg1;
25783   {
25784     try {
25785       delete arg1;
25786     } catch (std::out_of_range& e) {
25787       {
25788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25789       };
25790     } catch (std::exception& e) {
25791       {
25792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25793       };
25794     } catch (Dali::DaliException e) {
25795       {
25796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25797       };
25798     } catch (...) {
25799       {
25800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25801       };
25802     }
25803   }
25804
25805 }
25806
25807
25808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25809   void * jresult ;
25810   Dali::Geometry *arg1 = 0 ;
25811   Dali::Geometry *result = 0 ;
25812
25813   arg1 = (Dali::Geometry *)jarg1;
25814   if (!arg1) {
25815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25816     return 0;
25817   }
25818   {
25819     try {
25820       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25821     } catch (std::out_of_range& e) {
25822       {
25823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25824       };
25825     } catch (std::exception& e) {
25826       {
25827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25828       };
25829     } catch (Dali::DaliException e) {
25830       {
25831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25832       };
25833     } catch (...) {
25834       {
25835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25836       };
25837     }
25838   }
25839
25840   jresult = (void *)result;
25841   return jresult;
25842 }
25843
25844
25845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25846   void * jresult ;
25847   Dali::BaseHandle arg1 ;
25848   Dali::BaseHandle *argp1 ;
25849   Dali::Geometry result;
25850
25851   argp1 = (Dali::BaseHandle *)jarg1;
25852   if (!argp1) {
25853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25854     return 0;
25855   }
25856   arg1 = *argp1;
25857   {
25858     try {
25859       result = Dali::Geometry::DownCast(arg1);
25860     } catch (std::out_of_range& e) {
25861       {
25862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25863       };
25864     } catch (std::exception& e) {
25865       {
25866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25867       };
25868     } catch (Dali::DaliException e) {
25869       {
25870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25871       };
25872     } catch (...) {
25873       {
25874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25875       };
25876     }
25877   }
25878
25879   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25880   return jresult;
25881 }
25882
25883
25884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25885   void * jresult ;
25886   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25887   Dali::Geometry *arg2 = 0 ;
25888   Dali::Geometry *result = 0 ;
25889
25890   arg1 = (Dali::Geometry *)jarg1;
25891   arg2 = (Dali::Geometry *)jarg2;
25892   if (!arg2) {
25893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25894     return 0;
25895   }
25896   {
25897     try {
25898       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25899     } catch (std::out_of_range& e) {
25900       {
25901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25902       };
25903     } catch (std::exception& e) {
25904       {
25905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25906       };
25907     } catch (Dali::DaliException e) {
25908       {
25909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25910       };
25911     } catch (...) {
25912       {
25913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25914       };
25915     }
25916   }
25917
25918   jresult = (void *)result;
25919   return jresult;
25920 }
25921
25922
25923 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25924   unsigned long jresult ;
25925   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25926   Dali::PropertyBuffer *arg2 = 0 ;
25927   std::size_t result;
25928
25929   arg1 = (Dali::Geometry *)jarg1;
25930   arg2 = (Dali::PropertyBuffer *)jarg2;
25931   if (!arg2) {
25932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25933     return 0;
25934   }
25935   {
25936     try {
25937       result = (arg1)->AddVertexBuffer(*arg2);
25938     } catch (std::out_of_range& e) {
25939       {
25940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25941       };
25942     } catch (std::exception& e) {
25943       {
25944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25945       };
25946     } catch (Dali::DaliException e) {
25947       {
25948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25949       };
25950     } catch (...) {
25951       {
25952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25953       };
25954     }
25955   }
25956
25957   jresult = (unsigned long)result;
25958   return jresult;
25959 }
25960
25961
25962 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25963   unsigned long jresult ;
25964   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25965   std::size_t result;
25966
25967   arg1 = (Dali::Geometry *)jarg1;
25968   {
25969     try {
25970       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25971     } catch (std::out_of_range& e) {
25972       {
25973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25974       };
25975     } catch (std::exception& e) {
25976       {
25977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25978       };
25979     } catch (Dali::DaliException e) {
25980       {
25981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25982       };
25983     } catch (...) {
25984       {
25985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25986       };
25987     }
25988   }
25989
25990   jresult = (unsigned long)result;
25991   return jresult;
25992 }
25993
25994
25995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25996   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25997   std::size_t arg2 ;
25998
25999   arg1 = (Dali::Geometry *)jarg1;
26000   arg2 = (std::size_t)jarg2;
26001   {
26002     try {
26003       (arg1)->RemoveVertexBuffer(arg2);
26004     } catch (std::out_of_range& e) {
26005       {
26006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26007       };
26008     } catch (std::exception& e) {
26009       {
26010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26011       };
26012     } catch (Dali::DaliException e) {
26013       {
26014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26015       };
26016     } catch (...) {
26017       {
26018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26019       };
26020     }
26021   }
26022
26023 }
26024
26025
26026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26027   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26028   unsigned short *arg2 = (unsigned short *) 0 ;
26029   size_t arg3 ;
26030
26031   arg1 = (Dali::Geometry *)jarg1;
26032   arg2 = jarg2;
26033   arg3 = (size_t)jarg3;
26034   {
26035     try {
26036       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26037     } catch (std::out_of_range& e) {
26038       {
26039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26040       };
26041     } catch (std::exception& e) {
26042       {
26043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26044       };
26045     } catch (Dali::DaliException e) {
26046       {
26047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26048       };
26049     } catch (...) {
26050       {
26051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26052       };
26053     }
26054   }
26055
26056
26057
26058 }
26059
26060
26061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26062   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26063   Dali::Geometry::Type arg2 ;
26064
26065   arg1 = (Dali::Geometry *)jarg1;
26066   arg2 = (Dali::Geometry::Type)jarg2;
26067   {
26068     try {
26069       (arg1)->SetType(arg2);
26070     } catch (std::out_of_range& e) {
26071       {
26072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26073       };
26074     } catch (std::exception& e) {
26075       {
26076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26077       };
26078     } catch (Dali::DaliException e) {
26079       {
26080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26081       };
26082     } catch (...) {
26083       {
26084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26085       };
26086     }
26087   }
26088
26089 }
26090
26091
26092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26093   int jresult ;
26094   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26095   Dali::Geometry::Type result;
26096
26097   arg1 = (Dali::Geometry *)jarg1;
26098   {
26099     try {
26100       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26101     } catch (std::out_of_range& e) {
26102       {
26103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26104       };
26105     } catch (std::exception& e) {
26106       {
26107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26108       };
26109     } catch (Dali::DaliException e) {
26110       {
26111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26112       };
26113     } catch (...) {
26114       {
26115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26116       };
26117     }
26118   }
26119
26120   jresult = (int)result;
26121   return jresult;
26122 }
26123
26124
26125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26126   void * jresult ;
26127   Dali::Shader::Hint *result = 0 ;
26128
26129   {
26130     try {
26131       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26132     } catch (std::out_of_range& e) {
26133       {
26134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26135       };
26136     } catch (std::exception& e) {
26137       {
26138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26139       };
26140     } catch (Dali::DaliException e) {
26141       {
26142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26143       };
26144     } catch (...) {
26145       {
26146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26147       };
26148     }
26149   }
26150
26151   jresult = (void *)result;
26152   return jresult;
26153 }
26154
26155
26156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26157   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26158
26159   arg1 = (Dali::Shader::Hint *)jarg1;
26160   {
26161     try {
26162       delete arg1;
26163     } catch (std::out_of_range& e) {
26164       {
26165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26166       };
26167     } catch (std::exception& e) {
26168       {
26169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26170       };
26171     } catch (Dali::DaliException e) {
26172       {
26173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26174       };
26175     } catch (...) {
26176       {
26177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26178       };
26179     }
26180   }
26181
26182 }
26183
26184
26185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26186   int jresult ;
26187   int result;
26188
26189   result = (int)Dali::Shader::Property::PROGRAM;
26190   jresult = (int)result;
26191   return jresult;
26192 }
26193
26194
26195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26196   void * jresult ;
26197   Dali::Shader::Property *result = 0 ;
26198
26199   {
26200     try {
26201       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26202     } catch (std::out_of_range& e) {
26203       {
26204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26205       };
26206     } catch (std::exception& e) {
26207       {
26208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26209       };
26210     } catch (Dali::DaliException e) {
26211       {
26212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26213       };
26214     } catch (...) {
26215       {
26216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26217       };
26218     }
26219   }
26220
26221   jresult = (void *)result;
26222   return jresult;
26223 }
26224
26225
26226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26227   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26228
26229   arg1 = (Dali::Shader::Property *)jarg1;
26230   {
26231     try {
26232       delete arg1;
26233     } catch (std::out_of_range& e) {
26234       {
26235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26236       };
26237     } catch (std::exception& e) {
26238       {
26239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26240       };
26241     } catch (Dali::DaliException e) {
26242       {
26243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26244       };
26245     } catch (...) {
26246       {
26247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26248       };
26249     }
26250   }
26251
26252 }
26253
26254
26255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26256   void * jresult ;
26257   std::string *arg1 = 0 ;
26258   std::string *arg2 = 0 ;
26259   Dali::Shader::Hint::Value arg3 ;
26260   Dali::Shader result;
26261
26262   if (!jarg1) {
26263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26264     return 0;
26265   }
26266   std::string arg1_str(jarg1);
26267   arg1 = &arg1_str;
26268   if (!jarg2) {
26269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26270     return 0;
26271   }
26272   std::string arg2_str(jarg2);
26273   arg2 = &arg2_str;
26274   arg3 = (Dali::Shader::Hint::Value)jarg3;
26275   {
26276     try {
26277       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26278     } catch (std::out_of_range& e) {
26279       {
26280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26281       };
26282     } catch (std::exception& e) {
26283       {
26284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26285       };
26286     } catch (Dali::DaliException e) {
26287       {
26288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26289       };
26290     } catch (...) {
26291       {
26292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26293       };
26294     }
26295   }
26296
26297   jresult = new Dali::Shader((const Dali::Shader &)result);
26298
26299   //argout typemap for const std::string&
26300
26301
26302   //argout typemap for const std::string&
26303
26304   return jresult;
26305 }
26306
26307
26308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26309   void * jresult ;
26310   std::string *arg1 = 0 ;
26311   std::string *arg2 = 0 ;
26312   Dali::Shader result;
26313
26314   if (!jarg1) {
26315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26316     return 0;
26317   }
26318   std::string arg1_str(jarg1);
26319   arg1 = &arg1_str;
26320   if (!jarg2) {
26321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26322     return 0;
26323   }
26324   std::string arg2_str(jarg2);
26325   arg2 = &arg2_str;
26326   {
26327     try {
26328       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26329     } catch (std::out_of_range& e) {
26330       {
26331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26332       };
26333     } catch (std::exception& e) {
26334       {
26335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26336       };
26337     } catch (Dali::DaliException e) {
26338       {
26339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26340       };
26341     } catch (...) {
26342       {
26343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26344       };
26345     }
26346   }
26347
26348   jresult = new Dali::Shader((const Dali::Shader &)result);
26349
26350   //argout typemap for const std::string&
26351
26352
26353   //argout typemap for const std::string&
26354
26355   return jresult;
26356 }
26357
26358
26359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26360   void * jresult ;
26361   Dali::Shader *result = 0 ;
26362
26363   {
26364     try {
26365       result = (Dali::Shader *)new Dali::Shader();
26366     } catch (std::out_of_range& e) {
26367       {
26368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26369       };
26370     } catch (std::exception& e) {
26371       {
26372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26373       };
26374     } catch (Dali::DaliException e) {
26375       {
26376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26377       };
26378     } catch (...) {
26379       {
26380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26381       };
26382     }
26383   }
26384
26385   jresult = (void *)result;
26386   return jresult;
26387 }
26388
26389
26390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26391   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26392
26393   arg1 = (Dali::Shader *)jarg1;
26394   {
26395     try {
26396       delete arg1;
26397     } catch (std::out_of_range& e) {
26398       {
26399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26400       };
26401     } catch (std::exception& e) {
26402       {
26403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26404       };
26405     } catch (Dali::DaliException e) {
26406       {
26407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26408       };
26409     } catch (...) {
26410       {
26411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26412       };
26413     }
26414   }
26415
26416 }
26417
26418
26419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26420   void * jresult ;
26421   Dali::Shader *arg1 = 0 ;
26422   Dali::Shader *result = 0 ;
26423
26424   arg1 = (Dali::Shader *)jarg1;
26425   if (!arg1) {
26426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26427     return 0;
26428   }
26429   {
26430     try {
26431       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26432     } catch (std::out_of_range& e) {
26433       {
26434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26435       };
26436     } catch (std::exception& e) {
26437       {
26438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26439       };
26440     } catch (Dali::DaliException e) {
26441       {
26442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26443       };
26444     } catch (...) {
26445       {
26446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26447       };
26448     }
26449   }
26450
26451   jresult = (void *)result;
26452   return jresult;
26453 }
26454
26455
26456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26457   void * jresult ;
26458   Dali::BaseHandle arg1 ;
26459   Dali::BaseHandle *argp1 ;
26460   Dali::Shader result;
26461
26462   argp1 = (Dali::BaseHandle *)jarg1;
26463   if (!argp1) {
26464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26465     return 0;
26466   }
26467   arg1 = *argp1;
26468   {
26469     try {
26470       result = Dali::Shader::DownCast(arg1);
26471     } catch (std::out_of_range& e) {
26472       {
26473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26474       };
26475     } catch (std::exception& e) {
26476       {
26477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26478       };
26479     } catch (Dali::DaliException e) {
26480       {
26481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26482       };
26483     } catch (...) {
26484       {
26485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26486       };
26487     }
26488   }
26489
26490   jresult = new Dali::Shader((const Dali::Shader &)result);
26491   return jresult;
26492 }
26493
26494
26495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26496   void * jresult ;
26497   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26498   Dali::Shader *arg2 = 0 ;
26499   Dali::Shader *result = 0 ;
26500
26501   arg1 = (Dali::Shader *)jarg1;
26502   arg2 = (Dali::Shader *)jarg2;
26503   if (!arg2) {
26504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26505     return 0;
26506   }
26507   {
26508     try {
26509       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26510     } catch (std::out_of_range& e) {
26511       {
26512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26513       };
26514     } catch (std::exception& e) {
26515       {
26516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26517       };
26518     } catch (Dali::DaliException e) {
26519       {
26520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26521       };
26522     } catch (...) {
26523       {
26524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26525       };
26526     }
26527   }
26528
26529   jresult = (void *)result;
26530   return jresult;
26531 }
26532
26533
26534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26535   int jresult ;
26536   int result;
26537
26538   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26539   jresult = (int)result;
26540   return jresult;
26541 }
26542
26543
26544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26545   int jresult ;
26546   int result;
26547
26548   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26549   jresult = (int)result;
26550   return jresult;
26551 }
26552
26553
26554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26555   int jresult ;
26556   int result;
26557
26558   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26559   jresult = (int)result;
26560   return jresult;
26561 }
26562
26563
26564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26565   int jresult ;
26566   int result;
26567
26568   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26569   jresult = (int)result;
26570   return jresult;
26571 }
26572
26573
26574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26575   int jresult ;
26576   int result;
26577
26578   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26579   jresult = (int)result;
26580   return jresult;
26581 }
26582
26583
26584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26585   int jresult ;
26586   int result;
26587
26588   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26589   jresult = (int)result;
26590   return jresult;
26591 }
26592
26593
26594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26595   int jresult ;
26596   int result;
26597
26598   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26599   jresult = (int)result;
26600   return jresult;
26601 }
26602
26603
26604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26605   int jresult ;
26606   int result;
26607
26608   result = (int)Dali::Renderer::Property::BLEND_MODE;
26609   jresult = (int)result;
26610   return jresult;
26611 }
26612
26613
26614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26615   int jresult ;
26616   int result;
26617
26618   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26619   jresult = (int)result;
26620   return jresult;
26621 }
26622
26623
26624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26625   int jresult ;
26626   int result;
26627
26628   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26629   jresult = (int)result;
26630   return jresult;
26631 }
26632
26633
26634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26635   int jresult ;
26636   int result;
26637
26638   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26639   jresult = (int)result;
26640   return jresult;
26641 }
26642
26643
26644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26645   int jresult ;
26646   int result;
26647
26648   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26649   jresult = (int)result;
26650   return jresult;
26651 }
26652
26653
26654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26655   int jresult ;
26656   int result;
26657
26658   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26659   jresult = (int)result;
26660   return jresult;
26661 }
26662
26663
26664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26665   int jresult ;
26666   int result;
26667
26668   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26669   jresult = (int)result;
26670   return jresult;
26671 }
26672
26673
26674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26675   int jresult ;
26676   int result;
26677
26678   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26679   jresult = (int)result;
26680   return jresult;
26681 }
26682
26683
26684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26685   int jresult ;
26686   int result;
26687
26688   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26689   jresult = (int)result;
26690   return jresult;
26691 }
26692
26693
26694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26695   int jresult ;
26696   int result;
26697
26698   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26699   jresult = (int)result;
26700   return jresult;
26701 }
26702
26703
26704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26705   int jresult ;
26706   int result;
26707
26708   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26709   jresult = (int)result;
26710   return jresult;
26711 }
26712
26713
26714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26715   int jresult ;
26716   int result;
26717
26718   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26719   jresult = (int)result;
26720   return jresult;
26721 }
26722
26723
26724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26725   int jresult ;
26726   int result;
26727
26728   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26729   jresult = (int)result;
26730   return jresult;
26731 }
26732
26733
26734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26735   int jresult ;
26736   int result;
26737
26738   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26739   jresult = (int)result;
26740   return jresult;
26741 }
26742
26743
26744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26745   int jresult ;
26746   int result;
26747
26748   result = (int)Dali::Renderer::Property::RENDER_MODE;
26749   jresult = (int)result;
26750   return jresult;
26751 }
26752
26753
26754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26755   int jresult ;
26756   int result;
26757
26758   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26759   jresult = (int)result;
26760   return jresult;
26761 }
26762
26763
26764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26765   int jresult ;
26766   int result;
26767
26768   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26769   jresult = (int)result;
26770   return jresult;
26771 }
26772
26773
26774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26775   int jresult ;
26776   int result;
26777
26778   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26779   jresult = (int)result;
26780   return jresult;
26781 }
26782
26783
26784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26785   int jresult ;
26786   int result;
26787
26788   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26789   jresult = (int)result;
26790   return jresult;
26791 }
26792
26793
26794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26795   int jresult ;
26796   int result;
26797
26798   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26799   jresult = (int)result;
26800   return jresult;
26801 }
26802
26803
26804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26805   int jresult ;
26806   int result;
26807
26808   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26809   jresult = (int)result;
26810   return jresult;
26811 }
26812
26813
26814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26815   int jresult ;
26816   int result;
26817
26818   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26819   jresult = (int)result;
26820   return jresult;
26821 }
26822
26823
26824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26825   void * jresult ;
26826   Dali::Renderer::Property *result = 0 ;
26827
26828   {
26829     try {
26830       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26831     } catch (std::out_of_range& e) {
26832       {
26833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26834       };
26835     } catch (std::exception& e) {
26836       {
26837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26838       };
26839     } catch (Dali::DaliException e) {
26840       {
26841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26842       };
26843     } catch (...) {
26844       {
26845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26846       };
26847     }
26848   }
26849
26850   jresult = (void *)result;
26851   return jresult;
26852 }
26853
26854
26855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26856   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26857
26858   arg1 = (Dali::Renderer::Property *)jarg1;
26859   {
26860     try {
26861       delete arg1;
26862     } catch (std::out_of_range& e) {
26863       {
26864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26865       };
26866     } catch (std::exception& e) {
26867       {
26868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26869       };
26870     } catch (Dali::DaliException e) {
26871       {
26872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26873       };
26874     } catch (...) {
26875       {
26876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26877       };
26878     }
26879   }
26880
26881 }
26882
26883
26884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26885   void * jresult ;
26886   Dali::Geometry *arg1 = 0 ;
26887   Dali::Shader *arg2 = 0 ;
26888   Dali::Renderer result;
26889
26890   arg1 = (Dali::Geometry *)jarg1;
26891   if (!arg1) {
26892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26893     return 0;
26894   }
26895   arg2 = (Dali::Shader *)jarg2;
26896   if (!arg2) {
26897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26898     return 0;
26899   }
26900   {
26901     try {
26902       result = Dali::Renderer::New(*arg1,*arg2);
26903     } catch (std::out_of_range& e) {
26904       {
26905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26906       };
26907     } catch (std::exception& e) {
26908       {
26909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26910       };
26911     } catch (Dali::DaliException e) {
26912       {
26913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26914       };
26915     } catch (...) {
26916       {
26917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26918       };
26919     }
26920   }
26921
26922   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26923   return jresult;
26924 }
26925
26926
26927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26928   void * jresult ;
26929   Dali::Renderer *result = 0 ;
26930
26931   {
26932     try {
26933       result = (Dali::Renderer *)new Dali::Renderer();
26934     } catch (std::out_of_range& e) {
26935       {
26936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26937       };
26938     } catch (std::exception& e) {
26939       {
26940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26941       };
26942     } catch (Dali::DaliException e) {
26943       {
26944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26945       };
26946     } catch (...) {
26947       {
26948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26949       };
26950     }
26951   }
26952
26953   jresult = (void *)result;
26954   return jresult;
26955 }
26956
26957
26958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26959   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26960
26961   arg1 = (Dali::Renderer *)jarg1;
26962   {
26963     try {
26964       delete arg1;
26965     } catch (std::out_of_range& e) {
26966       {
26967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26968       };
26969     } catch (std::exception& e) {
26970       {
26971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26972       };
26973     } catch (Dali::DaliException e) {
26974       {
26975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26976       };
26977     } catch (...) {
26978       {
26979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26980       };
26981     }
26982   }
26983
26984 }
26985
26986
26987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26988   void * jresult ;
26989   Dali::Renderer *arg1 = 0 ;
26990   Dali::Renderer *result = 0 ;
26991
26992   arg1 = (Dali::Renderer *)jarg1;
26993   if (!arg1) {
26994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26995     return 0;
26996   }
26997   {
26998     try {
26999       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
27000     } catch (std::out_of_range& e) {
27001       {
27002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27003       };
27004     } catch (std::exception& e) {
27005       {
27006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27007       };
27008     } catch (Dali::DaliException e) {
27009       {
27010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27011       };
27012     } catch (...) {
27013       {
27014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27015       };
27016     }
27017   }
27018
27019   jresult = (void *)result;
27020   return jresult;
27021 }
27022
27023
27024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
27025   void * jresult ;
27026   Dali::BaseHandle arg1 ;
27027   Dali::BaseHandle *argp1 ;
27028   Dali::Renderer result;
27029
27030   argp1 = (Dali::BaseHandle *)jarg1;
27031   if (!argp1) {
27032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27033     return 0;
27034   }
27035   arg1 = *argp1;
27036   {
27037     try {
27038       result = Dali::Renderer::DownCast(arg1);
27039     } catch (std::out_of_range& e) {
27040       {
27041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27042       };
27043     } catch (std::exception& e) {
27044       {
27045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27046       };
27047     } catch (Dali::DaliException e) {
27048       {
27049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27050       };
27051     } catch (...) {
27052       {
27053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27054       };
27055     }
27056   }
27057
27058   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27059   return jresult;
27060 }
27061
27062
27063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27064   void * jresult ;
27065   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27066   Dali::Renderer *arg2 = 0 ;
27067   Dali::Renderer *result = 0 ;
27068
27069   arg1 = (Dali::Renderer *)jarg1;
27070   arg2 = (Dali::Renderer *)jarg2;
27071   if (!arg2) {
27072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27073     return 0;
27074   }
27075   {
27076     try {
27077       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27078     } catch (std::out_of_range& e) {
27079       {
27080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27081       };
27082     } catch (std::exception& e) {
27083       {
27084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27085       };
27086     } catch (Dali::DaliException e) {
27087       {
27088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27089       };
27090     } catch (...) {
27091       {
27092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27093       };
27094     }
27095   }
27096
27097   jresult = (void *)result;
27098   return jresult;
27099 }
27100
27101
27102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27103   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27104   Dali::Geometry *arg2 = 0 ;
27105
27106   arg1 = (Dali::Renderer *)jarg1;
27107   arg2 = (Dali::Geometry *)jarg2;
27108   if (!arg2) {
27109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27110     return ;
27111   }
27112   {
27113     try {
27114       (arg1)->SetGeometry(*arg2);
27115     } catch (std::out_of_range& e) {
27116       {
27117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27118       };
27119     } catch (std::exception& e) {
27120       {
27121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27122       };
27123     } catch (Dali::DaliException e) {
27124       {
27125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27126       };
27127     } catch (...) {
27128       {
27129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27130       };
27131     }
27132   }
27133
27134 }
27135
27136
27137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27138   void * jresult ;
27139   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27140   Dali::Geometry result;
27141
27142   arg1 = (Dali::Renderer *)jarg1;
27143   {
27144     try {
27145       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27146     } catch (std::out_of_range& e) {
27147       {
27148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27149       };
27150     } catch (std::exception& e) {
27151       {
27152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27153       };
27154     } catch (Dali::DaliException e) {
27155       {
27156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27157       };
27158     } catch (...) {
27159       {
27160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27161       };
27162     }
27163   }
27164
27165   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27166   return jresult;
27167 }
27168
27169
27170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27171   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27172   int arg2 ;
27173   int arg3 ;
27174
27175   arg1 = (Dali::Renderer *)jarg1;
27176   arg2 = (int)jarg2;
27177   arg3 = (int)jarg3;
27178   {
27179     try {
27180       (arg1)->SetIndexRange(arg2,arg3);
27181     } catch (std::out_of_range& e) {
27182       {
27183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27184       };
27185     } catch (std::exception& e) {
27186       {
27187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27188       };
27189     } catch (Dali::DaliException e) {
27190       {
27191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27192       };
27193     } catch (...) {
27194       {
27195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27196       };
27197     }
27198   }
27199
27200 }
27201
27202
27203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27204   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27205   Dali::TextureSet *arg2 = 0 ;
27206
27207   arg1 = (Dali::Renderer *)jarg1;
27208   arg2 = (Dali::TextureSet *)jarg2;
27209   if (!arg2) {
27210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27211     return ;
27212   }
27213   {
27214     try {
27215       (arg1)->SetTextures(*arg2);
27216     } catch (std::out_of_range& e) {
27217       {
27218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27219       };
27220     } catch (std::exception& e) {
27221       {
27222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27223       };
27224     } catch (Dali::DaliException e) {
27225       {
27226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27227       };
27228     } catch (...) {
27229       {
27230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27231       };
27232     }
27233   }
27234
27235 }
27236
27237
27238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27239   void * jresult ;
27240   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27241   Dali::TextureSet result;
27242
27243   arg1 = (Dali::Renderer *)jarg1;
27244   {
27245     try {
27246       result = ((Dali::Renderer const *)arg1)->GetTextures();
27247     } catch (std::out_of_range& e) {
27248       {
27249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27250       };
27251     } catch (std::exception& e) {
27252       {
27253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27254       };
27255     } catch (Dali::DaliException e) {
27256       {
27257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27258       };
27259     } catch (...) {
27260       {
27261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27262       };
27263     }
27264   }
27265
27266   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27267   return jresult;
27268 }
27269
27270
27271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27272   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27273   Dali::Shader *arg2 = 0 ;
27274
27275   arg1 = (Dali::Renderer *)jarg1;
27276   arg2 = (Dali::Shader *)jarg2;
27277   if (!arg2) {
27278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27279     return ;
27280   }
27281   {
27282     try {
27283       (arg1)->SetShader(*arg2);
27284     } catch (std::out_of_range& e) {
27285       {
27286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27287       };
27288     } catch (std::exception& e) {
27289       {
27290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27291       };
27292     } catch (Dali::DaliException e) {
27293       {
27294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27295       };
27296     } catch (...) {
27297       {
27298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27299       };
27300     }
27301   }
27302
27303 }
27304
27305
27306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27307   void * jresult ;
27308   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27309   Dali::Shader result;
27310
27311   arg1 = (Dali::Renderer *)jarg1;
27312   {
27313     try {
27314       result = ((Dali::Renderer const *)arg1)->GetShader();
27315     } catch (std::out_of_range& e) {
27316       {
27317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27318       };
27319     } catch (std::exception& e) {
27320       {
27321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27322       };
27323     } catch (Dali::DaliException e) {
27324       {
27325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27326       };
27327     } catch (...) {
27328       {
27329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27330       };
27331     }
27332   }
27333
27334   jresult = new Dali::Shader((const Dali::Shader &)result);
27335   return jresult;
27336 }
27337
27338
27339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27340   void * jresult ;
27341   Dali::FrameBuffer::Attachment *result = 0 ;
27342
27343   {
27344     try {
27345       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27346     } catch (std::out_of_range& e) {
27347       {
27348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27349       };
27350     } catch (std::exception& e) {
27351       {
27352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27353       };
27354     } catch (Dali::DaliException e) {
27355       {
27356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27357       };
27358     } catch (...) {
27359       {
27360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27361       };
27362     }
27363   }
27364
27365   jresult = (void *)result;
27366   return jresult;
27367 }
27368
27369
27370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27371   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27372
27373   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27374   {
27375     try {
27376       delete arg1;
27377     } catch (std::out_of_range& e) {
27378       {
27379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27380       };
27381     } catch (std::exception& e) {
27382       {
27383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27384       };
27385     } catch (Dali::DaliException e) {
27386       {
27387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27388       };
27389     } catch (...) {
27390       {
27391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27392       };
27393     }
27394   }
27395
27396 }
27397
27398
27399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27400   void * jresult ;
27401   unsigned int arg1 ;
27402   unsigned int arg2 ;
27403   unsigned int arg3 ;
27404   Dali::FrameBuffer result;
27405
27406   arg1 = (unsigned int)jarg1;
27407   arg2 = (unsigned int)jarg2;
27408   arg3 = (unsigned int)jarg3;
27409   {
27410     try {
27411       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27412     } catch (std::out_of_range& e) {
27413       {
27414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27415       };
27416     } catch (std::exception& e) {
27417       {
27418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27419       };
27420     } catch (Dali::DaliException e) {
27421       {
27422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27423       };
27424     } catch (...) {
27425       {
27426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27427       };
27428     }
27429   }
27430
27431   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27432   return jresult;
27433 }
27434
27435
27436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27437   void * jresult ;
27438   Dali::FrameBuffer *result = 0 ;
27439
27440   {
27441     try {
27442       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27443     } catch (std::out_of_range& e) {
27444       {
27445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27446       };
27447     } catch (std::exception& e) {
27448       {
27449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27450       };
27451     } catch (Dali::DaliException e) {
27452       {
27453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27454       };
27455     } catch (...) {
27456       {
27457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27458       };
27459     }
27460   }
27461
27462   jresult = (void *)result;
27463   return jresult;
27464 }
27465
27466
27467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27468   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27469
27470   arg1 = (Dali::FrameBuffer *)jarg1;
27471   {
27472     try {
27473       delete arg1;
27474     } catch (std::out_of_range& e) {
27475       {
27476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27477       };
27478     } catch (std::exception& e) {
27479       {
27480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27481       };
27482     } catch (Dali::DaliException e) {
27483       {
27484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27485       };
27486     } catch (...) {
27487       {
27488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27489       };
27490     }
27491   }
27492
27493 }
27494
27495
27496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27497   void * jresult ;
27498   Dali::FrameBuffer *arg1 = 0 ;
27499   Dali::FrameBuffer *result = 0 ;
27500
27501   arg1 = (Dali::FrameBuffer *)jarg1;
27502   if (!arg1) {
27503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27504     return 0;
27505   }
27506   {
27507     try {
27508       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27509     } catch (std::out_of_range& e) {
27510       {
27511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27512       };
27513     } catch (std::exception& e) {
27514       {
27515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27516       };
27517     } catch (Dali::DaliException e) {
27518       {
27519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27520       };
27521     } catch (...) {
27522       {
27523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27524       };
27525     }
27526   }
27527
27528   jresult = (void *)result;
27529   return jresult;
27530 }
27531
27532
27533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27534   void * jresult ;
27535   Dali::BaseHandle arg1 ;
27536   Dali::BaseHandle *argp1 ;
27537   Dali::FrameBuffer result;
27538
27539   argp1 = (Dali::BaseHandle *)jarg1;
27540   if (!argp1) {
27541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27542     return 0;
27543   }
27544   arg1 = *argp1;
27545   {
27546     try {
27547       result = Dali::FrameBuffer::DownCast(arg1);
27548     } catch (std::out_of_range& e) {
27549       {
27550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27551       };
27552     } catch (std::exception& e) {
27553       {
27554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27555       };
27556     } catch (Dali::DaliException e) {
27557       {
27558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27559       };
27560     } catch (...) {
27561       {
27562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27563       };
27564     }
27565   }
27566
27567   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27568   return jresult;
27569 }
27570
27571
27572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27573   void * jresult ;
27574   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27575   Dali::FrameBuffer *arg2 = 0 ;
27576   Dali::FrameBuffer *result = 0 ;
27577
27578   arg1 = (Dali::FrameBuffer *)jarg1;
27579   arg2 = (Dali::FrameBuffer *)jarg2;
27580   if (!arg2) {
27581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27582     return 0;
27583   }
27584   {
27585     try {
27586       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27587     } catch (std::out_of_range& e) {
27588       {
27589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27590       };
27591     } catch (std::exception& e) {
27592       {
27593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27594       };
27595     } catch (Dali::DaliException e) {
27596       {
27597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27598       };
27599     } catch (...) {
27600       {
27601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27602       };
27603     }
27604   }
27605
27606   jresult = (void *)result;
27607   return jresult;
27608 }
27609
27610
27611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27612   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27613   Dali::Texture *arg2 = 0 ;
27614
27615   arg1 = (Dali::FrameBuffer *)jarg1;
27616   arg2 = (Dali::Texture *)jarg2;
27617   if (!arg2) {
27618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27619     return ;
27620   }
27621   {
27622     try {
27623       (arg1)->AttachColorTexture(*arg2);
27624     } catch (std::out_of_range& e) {
27625       {
27626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27627       };
27628     } catch (std::exception& e) {
27629       {
27630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27631       };
27632     } catch (Dali::DaliException e) {
27633       {
27634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27635       };
27636     } catch (...) {
27637       {
27638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27639       };
27640     }
27641   }
27642
27643 }
27644
27645
27646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27647   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27648   Dali::Texture *arg2 = 0 ;
27649   unsigned int arg3 ;
27650   unsigned int arg4 ;
27651
27652   arg1 = (Dali::FrameBuffer *)jarg1;
27653   arg2 = (Dali::Texture *)jarg2;
27654   if (!arg2) {
27655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27656     return ;
27657   }
27658   arg3 = (unsigned int)jarg3;
27659   arg4 = (unsigned int)jarg4;
27660   {
27661     try {
27662       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27663     } catch (std::out_of_range& e) {
27664       {
27665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27666       };
27667     } catch (std::exception& e) {
27668       {
27669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27670       };
27671     } catch (Dali::DaliException e) {
27672       {
27673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27674       };
27675     } catch (...) {
27676       {
27677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27678       };
27679     }
27680   }
27681
27682 }
27683
27684
27685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27686   void * jresult ;
27687   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27688   Dali::Texture result;
27689
27690   arg1 = (Dali::FrameBuffer *)jarg1;
27691   {
27692     try {
27693       result = (arg1)->GetColorTexture();
27694     } catch (std::out_of_range& e) {
27695       {
27696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27697       };
27698     } catch (std::exception& e) {
27699       {
27700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27701       };
27702     } catch (Dali::DaliException e) {
27703       {
27704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27705       };
27706     } catch (...) {
27707       {
27708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27709       };
27710     }
27711   }
27712
27713   jresult = new Dali::Texture((const Dali::Texture &)result);
27714   return jresult;
27715 }
27716
27717
27718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27719   void * jresult ;
27720   Dali::RenderTaskList *result = 0 ;
27721
27722   {
27723     try {
27724       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27725     } catch (std::out_of_range& e) {
27726       {
27727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27728       };
27729     } catch (std::exception& e) {
27730       {
27731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27732       };
27733     } catch (Dali::DaliException e) {
27734       {
27735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27736       };
27737     } catch (...) {
27738       {
27739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27740       };
27741     }
27742   }
27743
27744   jresult = (void *)result;
27745   return jresult;
27746 }
27747
27748
27749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27750   void * jresult ;
27751   Dali::BaseHandle arg1 ;
27752   Dali::BaseHandle *argp1 ;
27753   Dali::RenderTaskList result;
27754
27755   argp1 = (Dali::BaseHandle *)jarg1;
27756   if (!argp1) {
27757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27758     return 0;
27759   }
27760   arg1 = *argp1;
27761   {
27762     try {
27763       result = Dali::RenderTaskList::DownCast(arg1);
27764     } catch (std::out_of_range& e) {
27765       {
27766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27767       };
27768     } catch (std::exception& e) {
27769       {
27770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27771       };
27772     } catch (Dali::DaliException e) {
27773       {
27774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27775       };
27776     } catch (...) {
27777       {
27778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27779       };
27780     }
27781   }
27782
27783   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27784   return jresult;
27785 }
27786
27787
27788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27789   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27790
27791   arg1 = (Dali::RenderTaskList *)jarg1;
27792   {
27793     try {
27794       delete arg1;
27795     } catch (std::out_of_range& e) {
27796       {
27797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27798       };
27799     } catch (std::exception& e) {
27800       {
27801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27802       };
27803     } catch (Dali::DaliException e) {
27804       {
27805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27806       };
27807     } catch (...) {
27808       {
27809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27810       };
27811     }
27812   }
27813
27814 }
27815
27816
27817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27818   void * jresult ;
27819   Dali::RenderTaskList *arg1 = 0 ;
27820   Dali::RenderTaskList *result = 0 ;
27821
27822   arg1 = (Dali::RenderTaskList *)jarg1;
27823   if (!arg1) {
27824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27825     return 0;
27826   }
27827   {
27828     try {
27829       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27830     } catch (std::out_of_range& e) {
27831       {
27832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27833       };
27834     } catch (std::exception& e) {
27835       {
27836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27837       };
27838     } catch (Dali::DaliException e) {
27839       {
27840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27841       };
27842     } catch (...) {
27843       {
27844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27845       };
27846     }
27847   }
27848
27849   jresult = (void *)result;
27850   return jresult;
27851 }
27852
27853
27854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27855   void * jresult ;
27856   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27857   Dali::RenderTaskList *arg2 = 0 ;
27858   Dali::RenderTaskList *result = 0 ;
27859
27860   arg1 = (Dali::RenderTaskList *)jarg1;
27861   arg2 = (Dali::RenderTaskList *)jarg2;
27862   if (!arg2) {
27863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27864     return 0;
27865   }
27866   {
27867     try {
27868       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27869     } catch (std::out_of_range& e) {
27870       {
27871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27872       };
27873     } catch (std::exception& e) {
27874       {
27875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27876       };
27877     } catch (Dali::DaliException e) {
27878       {
27879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27880       };
27881     } catch (...) {
27882       {
27883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27884       };
27885     }
27886   }
27887
27888   jresult = (void *)result;
27889   return jresult;
27890 }
27891
27892
27893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27894   void * jresult ;
27895   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27896   Dali::RenderTask result;
27897
27898   arg1 = (Dali::RenderTaskList *)jarg1;
27899   {
27900     try {
27901       result = (arg1)->CreateTask();
27902     } catch (std::out_of_range& e) {
27903       {
27904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27905       };
27906     } catch (std::exception& e) {
27907       {
27908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27909       };
27910     } catch (Dali::DaliException e) {
27911       {
27912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27913       };
27914     } catch (...) {
27915       {
27916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27917       };
27918     }
27919   }
27920
27921   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27922   return jresult;
27923 }
27924
27925
27926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27927   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27928   Dali::RenderTask arg2 ;
27929   Dali::RenderTask *argp2 ;
27930
27931   arg1 = (Dali::RenderTaskList *)jarg1;
27932   argp2 = (Dali::RenderTask *)jarg2;
27933   if (!argp2) {
27934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27935     return ;
27936   }
27937   arg2 = *argp2;
27938   {
27939     try {
27940       (arg1)->RemoveTask(arg2);
27941     } catch (std::out_of_range& e) {
27942       {
27943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27944       };
27945     } catch (std::exception& e) {
27946       {
27947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27948       };
27949     } catch (Dali::DaliException e) {
27950       {
27951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27952       };
27953     } catch (...) {
27954       {
27955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27956       };
27957     }
27958   }
27959
27960 }
27961
27962
27963 //// ===============================================end part 1 =================
27964
27965 //// ========================= part 2 ===============================
27966
27967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27968   unsigned int jresult ;
27969   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27970   unsigned int result;
27971
27972   arg1 = (Dali::RenderTaskList *)jarg1;
27973   {
27974     try {
27975       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27976     } catch (std::out_of_range& e) {
27977       {
27978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27979       };
27980     } catch (std::exception& e) {
27981       {
27982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27983       };
27984     } catch (Dali::DaliException e) {
27985       {
27986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27987       };
27988     } catch (...) {
27989       {
27990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27991       };
27992     }
27993   }
27994
27995   jresult = result;
27996   return jresult;
27997 }
27998
27999
28000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
28001   void * jresult ;
28002   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28003   unsigned int arg2 ;
28004   Dali::RenderTask result;
28005
28006   arg1 = (Dali::RenderTaskList *)jarg1;
28007   arg2 = (unsigned int)jarg2;
28008   {
28009     try {
28010       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
28011     } catch (std::out_of_range& e) {
28012       {
28013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28014       };
28015     } catch (std::exception& e) {
28016       {
28017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28018       };
28019     } catch (Dali::DaliException e) {
28020       {
28021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28022       };
28023     } catch (...) {
28024       {
28025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28026       };
28027     }
28028   }
28029
28030   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28031   return jresult;
28032 }
28033
28034
28035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
28036   int jresult ;
28037   int result;
28038
28039   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
28040   jresult = (int)result;
28041   return jresult;
28042 }
28043
28044
28045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
28046   int jresult ;
28047   int result;
28048
28049   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
28050   jresult = (int)result;
28051   return jresult;
28052 }
28053
28054
28055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28056   int jresult ;
28057   int result;
28058
28059   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28060   jresult = (int)result;
28061   return jresult;
28062 }
28063
28064
28065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28066   int jresult ;
28067   int result;
28068
28069   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28070   jresult = (int)result;
28071   return jresult;
28072 }
28073
28074
28075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28076   void * jresult ;
28077   Dali::RenderTask::Property *result = 0 ;
28078
28079   {
28080     try {
28081       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28082     } catch (std::out_of_range& e) {
28083       {
28084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28085       };
28086     } catch (std::exception& e) {
28087       {
28088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28089       };
28090     } catch (Dali::DaliException e) {
28091       {
28092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28093       };
28094     } catch (...) {
28095       {
28096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28097       };
28098     }
28099   }
28100
28101   jresult = (void *)result;
28102   return jresult;
28103 }
28104
28105
28106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28107   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28108
28109   arg1 = (Dali::RenderTask::Property *)jarg1;
28110   {
28111     try {
28112       delete arg1;
28113     } catch (std::out_of_range& e) {
28114       {
28115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28116       };
28117     } catch (std::exception& e) {
28118       {
28119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28120       };
28121     } catch (Dali::DaliException e) {
28122       {
28123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28124       };
28125     } catch (...) {
28126       {
28127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28128       };
28129     }
28130   }
28131
28132 }
28133
28134
28135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28136   void * jresult ;
28137   bool (*result)(Dali::Vector2 &) = 0 ;
28138
28139   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28140   jresult = (void *)result;
28141   return jresult;
28142 }
28143
28144
28145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28146   void * jresult ;
28147   bool (*result)(Dali::Vector2 &) = 0 ;
28148
28149   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28150   jresult = (void *)result;
28151   return jresult;
28152 }
28153
28154
28155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28156   unsigned int jresult ;
28157   bool result;
28158
28159   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28160   jresult = result;
28161   return jresult;
28162 }
28163
28164
28165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28166   unsigned int jresult ;
28167   bool result;
28168
28169   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28170   jresult = result;
28171   return jresult;
28172 }
28173
28174
28175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28176   void * jresult ;
28177   Dali::Vector4 *result = 0 ;
28178
28179   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28180   jresult = (void *)result;
28181   return jresult;
28182 }
28183
28184
28185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28186   unsigned int jresult ;
28187   bool result;
28188
28189   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28190   jresult = result;
28191   return jresult;
28192 }
28193
28194
28195 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28196   unsigned int jresult ;
28197   bool result;
28198
28199   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28200   jresult = result;
28201   return jresult;
28202 }
28203
28204
28205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28206   unsigned int jresult ;
28207   unsigned int result;
28208
28209   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28210   jresult = result;
28211   return jresult;
28212 }
28213
28214
28215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28216   void * jresult ;
28217   Dali::RenderTask *result = 0 ;
28218
28219   {
28220     try {
28221       result = (Dali::RenderTask *)new Dali::RenderTask();
28222     } catch (std::out_of_range& e) {
28223       {
28224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28225       };
28226     } catch (std::exception& e) {
28227       {
28228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28229       };
28230     } catch (Dali::DaliException e) {
28231       {
28232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28233       };
28234     } catch (...) {
28235       {
28236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28237       };
28238     }
28239   }
28240
28241   jresult = (void *)result;
28242   return jresult;
28243 }
28244
28245
28246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28247   void * jresult ;
28248   Dali::BaseHandle arg1 ;
28249   Dali::BaseHandle *argp1 ;
28250   Dali::RenderTask result;
28251
28252   argp1 = (Dali::BaseHandle *)jarg1;
28253   if (!argp1) {
28254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28255     return 0;
28256   }
28257   arg1 = *argp1;
28258   {
28259     try {
28260       result = Dali::RenderTask::DownCast(arg1);
28261     } catch (std::out_of_range& e) {
28262       {
28263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28264       };
28265     } catch (std::exception& e) {
28266       {
28267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28268       };
28269     } catch (Dali::DaliException e) {
28270       {
28271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28272       };
28273     } catch (...) {
28274       {
28275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28276       };
28277     }
28278   }
28279
28280   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28281   return jresult;
28282 }
28283
28284
28285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28286   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28287
28288   arg1 = (Dali::RenderTask *)jarg1;
28289   {
28290     try {
28291       delete arg1;
28292     } catch (std::out_of_range& e) {
28293       {
28294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28295       };
28296     } catch (std::exception& e) {
28297       {
28298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28299       };
28300     } catch (Dali::DaliException e) {
28301       {
28302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28303       };
28304     } catch (...) {
28305       {
28306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28307       };
28308     }
28309   }
28310
28311 }
28312
28313
28314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28315   void * jresult ;
28316   Dali::RenderTask *arg1 = 0 ;
28317   Dali::RenderTask *result = 0 ;
28318
28319   arg1 = (Dali::RenderTask *)jarg1;
28320   if (!arg1) {
28321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28322     return 0;
28323   }
28324   {
28325     try {
28326       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28327     } catch (std::out_of_range& e) {
28328       {
28329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28330       };
28331     } catch (std::exception& e) {
28332       {
28333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28334       };
28335     } catch (Dali::DaliException e) {
28336       {
28337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28338       };
28339     } catch (...) {
28340       {
28341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28342       };
28343     }
28344   }
28345
28346   jresult = (void *)result;
28347   return jresult;
28348 }
28349
28350
28351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28352   void * jresult ;
28353   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28354   Dali::RenderTask *arg2 = 0 ;
28355   Dali::RenderTask *result = 0 ;
28356
28357   arg1 = (Dali::RenderTask *)jarg1;
28358   arg2 = (Dali::RenderTask *)jarg2;
28359   if (!arg2) {
28360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28361     return 0;
28362   }
28363   {
28364     try {
28365       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28366     } catch (std::out_of_range& e) {
28367       {
28368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28369       };
28370     } catch (std::exception& e) {
28371       {
28372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28373       };
28374     } catch (Dali::DaliException e) {
28375       {
28376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28377       };
28378     } catch (...) {
28379       {
28380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28381       };
28382     }
28383   }
28384
28385   jresult = (void *)result;
28386   return jresult;
28387 }
28388
28389
28390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28391   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28392   Dali::Actor arg2 ;
28393   Dali::Actor *argp2 ;
28394
28395   arg1 = (Dali::RenderTask *)jarg1;
28396   argp2 = (Dali::Actor *)jarg2;
28397   if (!argp2) {
28398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28399     return ;
28400   }
28401   arg2 = *argp2;
28402   {
28403     try {
28404       (arg1)->SetSourceActor(arg2);
28405     } catch (std::out_of_range& e) {
28406       {
28407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28408       };
28409     } catch (std::exception& e) {
28410       {
28411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28412       };
28413     } catch (Dali::DaliException e) {
28414       {
28415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28416       };
28417     } catch (...) {
28418       {
28419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28420       };
28421     }
28422   }
28423
28424 }
28425
28426
28427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28428   void * jresult ;
28429   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28430   Dali::Actor result;
28431
28432   arg1 = (Dali::RenderTask *)jarg1;
28433   {
28434     try {
28435       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28436     } catch (std::out_of_range& e) {
28437       {
28438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28439       };
28440     } catch (std::exception& e) {
28441       {
28442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28443       };
28444     } catch (Dali::DaliException e) {
28445       {
28446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28447       };
28448     } catch (...) {
28449       {
28450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28451       };
28452     }
28453   }
28454
28455   jresult = new Dali::Actor((const Dali::Actor &)result);
28456   return jresult;
28457 }
28458
28459
28460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28461   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28462   bool arg2 ;
28463
28464   arg1 = (Dali::RenderTask *)jarg1;
28465   arg2 = jarg2 ? true : false;
28466   {
28467     try {
28468       (arg1)->SetExclusive(arg2);
28469     } catch (std::out_of_range& e) {
28470       {
28471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28472       };
28473     } catch (std::exception& e) {
28474       {
28475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28476       };
28477     } catch (Dali::DaliException e) {
28478       {
28479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28480       };
28481     } catch (...) {
28482       {
28483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28484       };
28485     }
28486   }
28487
28488 }
28489
28490
28491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28492   unsigned int jresult ;
28493   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28494   bool result;
28495
28496   arg1 = (Dali::RenderTask *)jarg1;
28497   {
28498     try {
28499       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28500     } catch (std::out_of_range& e) {
28501       {
28502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28503       };
28504     } catch (std::exception& e) {
28505       {
28506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28507       };
28508     } catch (Dali::DaliException e) {
28509       {
28510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28511       };
28512     } catch (...) {
28513       {
28514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28515       };
28516     }
28517   }
28518
28519   jresult = result;
28520   return jresult;
28521 }
28522
28523
28524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28525   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28526   bool arg2 ;
28527
28528   arg1 = (Dali::RenderTask *)jarg1;
28529   arg2 = jarg2 ? true : false;
28530   {
28531     try {
28532       (arg1)->SetInputEnabled(arg2);
28533     } catch (std::out_of_range& e) {
28534       {
28535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28536       };
28537     } catch (std::exception& e) {
28538       {
28539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28540       };
28541     } catch (Dali::DaliException e) {
28542       {
28543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28544       };
28545     } catch (...) {
28546       {
28547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28548       };
28549     }
28550   }
28551
28552 }
28553
28554
28555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28556   unsigned int jresult ;
28557   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28558   bool result;
28559
28560   arg1 = (Dali::RenderTask *)jarg1;
28561   {
28562     try {
28563       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28564     } catch (std::out_of_range& e) {
28565       {
28566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28567       };
28568     } catch (std::exception& e) {
28569       {
28570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28571       };
28572     } catch (Dali::DaliException e) {
28573       {
28574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28575       };
28576     } catch (...) {
28577       {
28578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28579       };
28580     }
28581   }
28582
28583   jresult = result;
28584   return jresult;
28585 }
28586
28587
28588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28589   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28590   Dali::CameraActor arg2 ;
28591   Dali::CameraActor *argp2 ;
28592
28593   arg1 = (Dali::RenderTask *)jarg1;
28594   argp2 = (Dali::CameraActor *)jarg2;
28595   if (!argp2) {
28596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28597     return ;
28598   }
28599   arg2 = *argp2;
28600   {
28601     try {
28602       (arg1)->SetCameraActor(arg2);
28603     } catch (std::out_of_range& e) {
28604       {
28605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28606       };
28607     } catch (std::exception& e) {
28608       {
28609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28610       };
28611     } catch (Dali::DaliException e) {
28612       {
28613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28614       };
28615     } catch (...) {
28616       {
28617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28618       };
28619     }
28620   }
28621
28622 }
28623
28624
28625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28626   void * jresult ;
28627   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28628   Dali::CameraActor result;
28629
28630   arg1 = (Dali::RenderTask *)jarg1;
28631   {
28632     try {
28633       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28634     } catch (std::out_of_range& e) {
28635       {
28636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28637       };
28638     } catch (std::exception& e) {
28639       {
28640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28641       };
28642     } catch (Dali::DaliException e) {
28643       {
28644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28645       };
28646     } catch (...) {
28647       {
28648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28649       };
28650     }
28651   }
28652
28653   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28654   return jresult;
28655 }
28656
28657
28658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28659   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28660   Dali::FrameBufferImage arg2 ;
28661   Dali::FrameBufferImage *argp2 ;
28662
28663   arg1 = (Dali::RenderTask *)jarg1;
28664   argp2 = (Dali::FrameBufferImage *)jarg2;
28665   if (!argp2) {
28666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28667     return ;
28668   }
28669   arg2 = *argp2;
28670   {
28671     try {
28672       (arg1)->SetTargetFrameBuffer(arg2);
28673     } catch (std::out_of_range& e) {
28674       {
28675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28676       };
28677     } catch (std::exception& e) {
28678       {
28679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28680       };
28681     } catch (Dali::DaliException e) {
28682       {
28683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28684       };
28685     } catch (...) {
28686       {
28687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28688       };
28689     }
28690   }
28691
28692 }
28693
28694
28695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28696   void * jresult ;
28697   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28698   Dali::FrameBufferImage result;
28699
28700   arg1 = (Dali::RenderTask *)jarg1;
28701   {
28702     try {
28703       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28704     } catch (std::out_of_range& e) {
28705       {
28706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28707       };
28708     } catch (std::exception& e) {
28709       {
28710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28711       };
28712     } catch (Dali::DaliException e) {
28713       {
28714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28715       };
28716     } catch (...) {
28717       {
28718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28719       };
28720     }
28721   }
28722
28723   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28724   return jresult;
28725 }
28726
28727
28728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28729   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28730   Dali::FrameBuffer arg2 ;
28731   Dali::FrameBuffer *argp2 ;
28732
28733   arg1 = (Dali::RenderTask *)jarg1;
28734   argp2 = (Dali::FrameBuffer *)jarg2;
28735   if (!argp2) {
28736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28737     return ;
28738   }
28739   arg2 = *argp2;
28740   {
28741     try {
28742       (arg1)->SetFrameBuffer(arg2);
28743     } catch (std::out_of_range& e) {
28744       {
28745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28746       };
28747     } catch (std::exception& e) {
28748       {
28749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28750       };
28751     } catch (Dali::DaliException e) {
28752       {
28753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28754       };
28755     } catch (...) {
28756       {
28757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28758       };
28759     }
28760   }
28761
28762 }
28763
28764
28765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28766   void * jresult ;
28767   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28768   Dali::FrameBuffer result;
28769
28770   arg1 = (Dali::RenderTask *)jarg1;
28771   {
28772     try {
28773       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28774     } catch (std::out_of_range& e) {
28775       {
28776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28777       };
28778     } catch (std::exception& e) {
28779       {
28780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28781       };
28782     } catch (Dali::DaliException e) {
28783       {
28784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28785       };
28786     } catch (...) {
28787       {
28788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28789       };
28790     }
28791   }
28792
28793   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28794   return jresult;
28795 }
28796
28797
28798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28799   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28800   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28801
28802   arg1 = (Dali::RenderTask *)jarg1;
28803   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28804   {
28805     try {
28806       (arg1)->SetScreenToFrameBufferFunction(arg2);
28807     } catch (std::out_of_range& e) {
28808       {
28809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28810       };
28811     } catch (std::exception& e) {
28812       {
28813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28814       };
28815     } catch (Dali::DaliException e) {
28816       {
28817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28818       };
28819     } catch (...) {
28820       {
28821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28822       };
28823     }
28824   }
28825
28826 }
28827
28828
28829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28830   void * jresult ;
28831   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28832   Dali::RenderTask::ScreenToFrameBufferFunction result;
28833
28834   arg1 = (Dali::RenderTask *)jarg1;
28835   {
28836     try {
28837       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28838     } catch (std::out_of_range& e) {
28839       {
28840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28841       };
28842     } catch (std::exception& e) {
28843       {
28844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28845       };
28846     } catch (Dali::DaliException e) {
28847       {
28848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28849       };
28850     } catch (...) {
28851       {
28852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28853       };
28854     }
28855   }
28856
28857   jresult = (void *)result;
28858   return jresult;
28859 }
28860
28861
28862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28863   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28864   Dali::Actor arg2 ;
28865   Dali::Actor *argp2 ;
28866
28867   arg1 = (Dali::RenderTask *)jarg1;
28868   argp2 = (Dali::Actor *)jarg2;
28869   if (!argp2) {
28870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28871     return ;
28872   }
28873   arg2 = *argp2;
28874   {
28875     try {
28876       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28877     } catch (std::out_of_range& e) {
28878       {
28879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28880       };
28881     } catch (std::exception& e) {
28882       {
28883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28884       };
28885     } catch (Dali::DaliException e) {
28886       {
28887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28888       };
28889     } catch (...) {
28890       {
28891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28892       };
28893     }
28894   }
28895
28896 }
28897
28898
28899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28900   void * jresult ;
28901   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28902   Dali::Actor result;
28903
28904   arg1 = (Dali::RenderTask *)jarg1;
28905   {
28906     try {
28907       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28908     } catch (std::out_of_range& e) {
28909       {
28910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28911       };
28912     } catch (std::exception& e) {
28913       {
28914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28915       };
28916     } catch (Dali::DaliException e) {
28917       {
28918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28919       };
28920     } catch (...) {
28921       {
28922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28923       };
28924     }
28925   }
28926
28927   jresult = new Dali::Actor((const Dali::Actor &)result);
28928   return jresult;
28929 }
28930
28931
28932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28933   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28934   Dali::Vector2 arg2 ;
28935   Dali::Vector2 *argp2 ;
28936
28937   arg1 = (Dali::RenderTask *)jarg1;
28938   argp2 = (Dali::Vector2 *)jarg2;
28939   if (!argp2) {
28940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28941     return ;
28942   }
28943   arg2 = *argp2;
28944   {
28945     try {
28946       (arg1)->SetViewportPosition(arg2);
28947     } catch (std::out_of_range& e) {
28948       {
28949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28950       };
28951     } catch (std::exception& e) {
28952       {
28953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28954       };
28955     } catch (Dali::DaliException e) {
28956       {
28957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28958       };
28959     } catch (...) {
28960       {
28961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28962       };
28963     }
28964   }
28965
28966 }
28967
28968
28969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28970   void * jresult ;
28971   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28972   Dali::Vector2 result;
28973
28974   arg1 = (Dali::RenderTask *)jarg1;
28975   {
28976     try {
28977       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28978     } catch (std::out_of_range& e) {
28979       {
28980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28981       };
28982     } catch (std::exception& e) {
28983       {
28984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28985       };
28986     } catch (Dali::DaliException e) {
28987       {
28988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28989       };
28990     } catch (...) {
28991       {
28992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28993       };
28994     }
28995   }
28996
28997   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28998   return jresult;
28999 }
29000
29001
29002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
29003   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29004   Dali::Vector2 arg2 ;
29005   Dali::Vector2 *argp2 ;
29006
29007   arg1 = (Dali::RenderTask *)jarg1;
29008   argp2 = (Dali::Vector2 *)jarg2;
29009   if (!argp2) {
29010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29011     return ;
29012   }
29013   arg2 = *argp2;
29014   {
29015     try {
29016       (arg1)->SetViewportSize(arg2);
29017     } catch (std::out_of_range& e) {
29018       {
29019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29020       };
29021     } catch (std::exception& e) {
29022       {
29023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29024       };
29025     } catch (Dali::DaliException e) {
29026       {
29027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29028       };
29029     } catch (...) {
29030       {
29031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29032       };
29033     }
29034   }
29035
29036 }
29037
29038
29039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
29040   void * jresult ;
29041   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29042   Dali::Vector2 result;
29043
29044   arg1 = (Dali::RenderTask *)jarg1;
29045   {
29046     try {
29047       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
29048     } catch (std::out_of_range& e) {
29049       {
29050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29051       };
29052     } catch (std::exception& e) {
29053       {
29054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29055       };
29056     } catch (Dali::DaliException e) {
29057       {
29058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29059       };
29060     } catch (...) {
29061       {
29062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29063       };
29064     }
29065   }
29066
29067   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29068   return jresult;
29069 }
29070
29071
29072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29073   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29074   Dali::Viewport arg2 ;
29075   Dali::Viewport *argp2 ;
29076
29077   arg1 = (Dali::RenderTask *)jarg1;
29078   argp2 = (Dali::Viewport *)jarg2;
29079   if (!argp2) {
29080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29081     return ;
29082   }
29083   arg2 = *argp2;
29084   {
29085     try {
29086       (arg1)->SetViewport(arg2);
29087     } catch (std::out_of_range& e) {
29088       {
29089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29090       };
29091     } catch (std::exception& e) {
29092       {
29093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29094       };
29095     } catch (Dali::DaliException e) {
29096       {
29097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29098       };
29099     } catch (...) {
29100       {
29101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29102       };
29103     }
29104   }
29105
29106 }
29107
29108
29109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29110   void * jresult ;
29111   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29112   Dali::Viewport result;
29113
29114   arg1 = (Dali::RenderTask *)jarg1;
29115   {
29116     try {
29117       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29118     } catch (std::out_of_range& e) {
29119       {
29120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29121       };
29122     } catch (std::exception& e) {
29123       {
29124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29125       };
29126     } catch (Dali::DaliException e) {
29127       {
29128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29129       };
29130     } catch (...) {
29131       {
29132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29133       };
29134     }
29135   }
29136
29137   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29138   return jresult;
29139 }
29140
29141
29142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29143   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29144   Dali::Vector4 *arg2 = 0 ;
29145
29146   arg1 = (Dali::RenderTask *)jarg1;
29147   arg2 = (Dali::Vector4 *)jarg2;
29148   if (!arg2) {
29149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29150     return ;
29151   }
29152   {
29153     try {
29154       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29155     } catch (std::out_of_range& e) {
29156       {
29157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29158       };
29159     } catch (std::exception& e) {
29160       {
29161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29162       };
29163     } catch (Dali::DaliException e) {
29164       {
29165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29166       };
29167     } catch (...) {
29168       {
29169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29170       };
29171     }
29172   }
29173
29174 }
29175
29176
29177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29178   void * jresult ;
29179   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29180   Dali::Vector4 result;
29181
29182   arg1 = (Dali::RenderTask *)jarg1;
29183   {
29184     try {
29185       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29186     } catch (std::out_of_range& e) {
29187       {
29188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29189       };
29190     } catch (std::exception& e) {
29191       {
29192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29193       };
29194     } catch (Dali::DaliException e) {
29195       {
29196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29197       };
29198     } catch (...) {
29199       {
29200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29201       };
29202     }
29203   }
29204
29205   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29206   return jresult;
29207 }
29208
29209
29210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29211   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29212   bool arg2 ;
29213
29214   arg1 = (Dali::RenderTask *)jarg1;
29215   arg2 = jarg2 ? true : false;
29216   {
29217     try {
29218       (arg1)->SetClearEnabled(arg2);
29219     } catch (std::out_of_range& e) {
29220       {
29221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29222       };
29223     } catch (std::exception& e) {
29224       {
29225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29226       };
29227     } catch (Dali::DaliException e) {
29228       {
29229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29230       };
29231     } catch (...) {
29232       {
29233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29234       };
29235     }
29236   }
29237
29238 }
29239
29240
29241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29242   unsigned int jresult ;
29243   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29244   bool result;
29245
29246   arg1 = (Dali::RenderTask *)jarg1;
29247   {
29248     try {
29249       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29250     } catch (std::out_of_range& e) {
29251       {
29252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29253       };
29254     } catch (std::exception& e) {
29255       {
29256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29257       };
29258     } catch (Dali::DaliException e) {
29259       {
29260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29261       };
29262     } catch (...) {
29263       {
29264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29265       };
29266     }
29267   }
29268
29269   jresult = result;
29270   return jresult;
29271 }
29272
29273
29274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29275   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29276   bool arg2 ;
29277
29278   arg1 = (Dali::RenderTask *)jarg1;
29279   arg2 = jarg2 ? true : false;
29280   {
29281     try {
29282       (arg1)->SetCullMode(arg2);
29283     } catch (std::out_of_range& e) {
29284       {
29285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29286       };
29287     } catch (std::exception& e) {
29288       {
29289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29290       };
29291     } catch (Dali::DaliException e) {
29292       {
29293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29294       };
29295     } catch (...) {
29296       {
29297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29298       };
29299     }
29300   }
29301
29302 }
29303
29304
29305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29306   unsigned int jresult ;
29307   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29308   bool result;
29309
29310   arg1 = (Dali::RenderTask *)jarg1;
29311   {
29312     try {
29313       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29314     } catch (std::out_of_range& e) {
29315       {
29316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29317       };
29318     } catch (std::exception& e) {
29319       {
29320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29321       };
29322     } catch (Dali::DaliException e) {
29323       {
29324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29325       };
29326     } catch (...) {
29327       {
29328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29329       };
29330     }
29331   }
29332
29333   jresult = result;
29334   return jresult;
29335 }
29336
29337
29338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29339   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29340   unsigned int arg2 ;
29341
29342   arg1 = (Dali::RenderTask *)jarg1;
29343   arg2 = (unsigned int)jarg2;
29344   {
29345     try {
29346       (arg1)->SetRefreshRate(arg2);
29347     } catch (std::out_of_range& e) {
29348       {
29349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29350       };
29351     } catch (std::exception& e) {
29352       {
29353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29354       };
29355     } catch (Dali::DaliException e) {
29356       {
29357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29358       };
29359     } catch (...) {
29360       {
29361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29362       };
29363     }
29364   }
29365
29366 }
29367
29368
29369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29370   unsigned int jresult ;
29371   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29372   unsigned int result;
29373
29374   arg1 = (Dali::RenderTask *)jarg1;
29375   {
29376     try {
29377       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29378     } catch (std::out_of_range& e) {
29379       {
29380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29381       };
29382     } catch (std::exception& e) {
29383       {
29384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29385       };
29386     } catch (Dali::DaliException e) {
29387       {
29388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29389       };
29390     } catch (...) {
29391       {
29392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29393       };
29394     }
29395   }
29396
29397   jresult = result;
29398   return jresult;
29399 }
29400
29401
29402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29403   unsigned int jresult ;
29404   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29405   Dali::Vector3 *arg2 = 0 ;
29406   float *arg3 = 0 ;
29407   float *arg4 = 0 ;
29408   bool result;
29409
29410   arg1 = (Dali::RenderTask *)jarg1;
29411   arg2 = (Dali::Vector3 *)jarg2;
29412   if (!arg2) {
29413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29414     return 0;
29415   }
29416   arg3 = (float *)jarg3;
29417   arg4 = (float *)jarg4;
29418   {
29419     try {
29420       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29421     } catch (std::out_of_range& e) {
29422       {
29423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29424       };
29425     } catch (std::exception& e) {
29426       {
29427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29428       };
29429     } catch (Dali::DaliException e) {
29430       {
29431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29432       };
29433     } catch (...) {
29434       {
29435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29436       };
29437     }
29438   }
29439
29440   jresult = result;
29441   return jresult;
29442 }
29443
29444
29445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29446   unsigned int jresult ;
29447   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29448   Dali::Actor arg2 ;
29449   float arg3 ;
29450   float arg4 ;
29451   float *arg5 = 0 ;
29452   float *arg6 = 0 ;
29453   Dali::Actor *argp2 ;
29454   bool result;
29455
29456   arg1 = (Dali::RenderTask *)jarg1;
29457   argp2 = (Dali::Actor *)jarg2;
29458   if (!argp2) {
29459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29460     return 0;
29461   }
29462   arg2 = *argp2;
29463   arg3 = (float)jarg3;
29464   arg4 = (float)jarg4;
29465   arg5 = (float *)jarg5;
29466   arg6 = (float *)jarg6;
29467   {
29468     try {
29469       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29470     } catch (std::out_of_range& e) {
29471       {
29472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29473       };
29474     } catch (std::exception& e) {
29475       {
29476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29477       };
29478     } catch (Dali::DaliException e) {
29479       {
29480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29481       };
29482     } catch (...) {
29483       {
29484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29485       };
29486     }
29487   }
29488
29489   jresult = result;
29490   return jresult;
29491 }
29492
29493
29494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29495   void * jresult ;
29496   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29497   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29498
29499   arg1 = (Dali::RenderTask *)jarg1;
29500   {
29501     try {
29502       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29503     } catch (std::out_of_range& e) {
29504       {
29505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29506       };
29507     } catch (std::exception& e) {
29508       {
29509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29510       };
29511     } catch (Dali::DaliException e) {
29512       {
29513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29514       };
29515     } catch (...) {
29516       {
29517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29518       };
29519     }
29520   }
29521
29522   jresult = (void *)result;
29523   return jresult;
29524 }
29525
29526
29527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29528   void * jresult ;
29529   int arg1 ;
29530   Dali::TouchPoint::State arg2 ;
29531   float arg3 ;
29532   float arg4 ;
29533   Dali::TouchPoint *result = 0 ;
29534
29535   arg1 = (int)jarg1;
29536   arg2 = (Dali::TouchPoint::State)jarg2;
29537   arg3 = (float)jarg3;
29538   arg4 = (float)jarg4;
29539   {
29540     try {
29541       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29542     } catch (std::out_of_range& e) {
29543       {
29544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29545       };
29546     } catch (std::exception& e) {
29547       {
29548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29549       };
29550     } catch (Dali::DaliException e) {
29551       {
29552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29553       };
29554     } catch (...) {
29555       {
29556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29557       };
29558     }
29559   }
29560
29561   jresult = (void *)result;
29562   return jresult;
29563 }
29564
29565
29566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29567   void * jresult ;
29568   int arg1 ;
29569   Dali::TouchPoint::State arg2 ;
29570   float arg3 ;
29571   float arg4 ;
29572   float arg5 ;
29573   float arg6 ;
29574   Dali::TouchPoint *result = 0 ;
29575
29576   arg1 = (int)jarg1;
29577   arg2 = (Dali::TouchPoint::State)jarg2;
29578   arg3 = (float)jarg3;
29579   arg4 = (float)jarg4;
29580   arg5 = (float)jarg5;
29581   arg6 = (float)jarg6;
29582   {
29583     try {
29584       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29585     } catch (std::out_of_range& e) {
29586       {
29587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29588       };
29589     } catch (std::exception& e) {
29590       {
29591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29592       };
29593     } catch (Dali::DaliException e) {
29594       {
29595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29596       };
29597     } catch (...) {
29598       {
29599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29600       };
29601     }
29602   }
29603
29604   jresult = (void *)result;
29605   return jresult;
29606 }
29607
29608
29609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29610   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29611
29612   arg1 = (Dali::TouchPoint *)jarg1;
29613   {
29614     try {
29615       delete arg1;
29616     } catch (std::out_of_range& e) {
29617       {
29618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29619       };
29620     } catch (std::exception& e) {
29621       {
29622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29623       };
29624     } catch (Dali::DaliException e) {
29625       {
29626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29627       };
29628     } catch (...) {
29629       {
29630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29631       };
29632     }
29633   }
29634
29635 }
29636
29637
29638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29639   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29640   int arg2 ;
29641
29642   arg1 = (Dali::TouchPoint *)jarg1;
29643   arg2 = (int)jarg2;
29644   if (arg1) (arg1)->deviceId = arg2;
29645 }
29646
29647
29648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29649   int jresult ;
29650   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29651   int result;
29652
29653   arg1 = (Dali::TouchPoint *)jarg1;
29654   result = (int) ((arg1)->deviceId);
29655   jresult = result;
29656   return jresult;
29657 }
29658
29659
29660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29661   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29662   Dali::TouchPoint::State arg2 ;
29663
29664   arg1 = (Dali::TouchPoint *)jarg1;
29665   arg2 = (Dali::TouchPoint::State)jarg2;
29666   if (arg1) (arg1)->state = arg2;
29667 }
29668
29669
29670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29671   int jresult ;
29672   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29673   Dali::TouchPoint::State result;
29674
29675   arg1 = (Dali::TouchPoint *)jarg1;
29676   result = (Dali::TouchPoint::State) ((arg1)->state);
29677   jresult = (int)result;
29678   return jresult;
29679 }
29680
29681
29682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29683   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29684   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29685
29686   arg1 = (Dali::TouchPoint *)jarg1;
29687   arg2 = (Dali::Actor *)jarg2;
29688   if (arg1) (arg1)->hitActor = *arg2;
29689 }
29690
29691
29692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29693   void * jresult ;
29694   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29695   Dali::Actor *result = 0 ;
29696
29697   arg1 = (Dali::TouchPoint *)jarg1;
29698   result = (Dali::Actor *)& ((arg1)->hitActor);
29699   jresult = (void *)result;
29700   return jresult;
29701 }
29702
29703
29704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29705   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29706   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29707
29708   arg1 = (Dali::TouchPoint *)jarg1;
29709   arg2 = (Dali::Vector2 *)jarg2;
29710   if (arg1) (arg1)->local = *arg2;
29711 }
29712
29713
29714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29715   void * jresult ;
29716   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29717   Dali::Vector2 *result = 0 ;
29718
29719   arg1 = (Dali::TouchPoint *)jarg1;
29720   result = (Dali::Vector2 *)& ((arg1)->local);
29721   jresult = (void *)result;
29722   return jresult;
29723 }
29724
29725
29726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29727   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29728   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29729
29730   arg1 = (Dali::TouchPoint *)jarg1;
29731   arg2 = (Dali::Vector2 *)jarg2;
29732   if (arg1) (arg1)->screen = *arg2;
29733 }
29734
29735
29736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29737   void * jresult ;
29738   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29739   Dali::Vector2 *result = 0 ;
29740
29741   arg1 = (Dali::TouchPoint *)jarg1;
29742   result = (Dali::Vector2 *)& ((arg1)->screen);
29743   jresult = (void *)result;
29744   return jresult;
29745 }
29746
29747
29748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29749   void * jresult ;
29750   Dali::TouchData *result = 0 ;
29751
29752   {
29753     try {
29754       result = (Dali::TouchData *)new Dali::TouchData();
29755     } catch (std::out_of_range& e) {
29756       {
29757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29758       };
29759     } catch (std::exception& e) {
29760       {
29761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29762       };
29763     } catch (Dali::DaliException e) {
29764       {
29765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29766       };
29767     } catch (...) {
29768       {
29769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29770       };
29771     }
29772   }
29773
29774   jresult = (void *)result;
29775   return jresult;
29776 }
29777
29778
29779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29780   void * jresult ;
29781   Dali::TouchData *arg1 = 0 ;
29782   Dali::TouchData *result = 0 ;
29783
29784   arg1 = (Dali::TouchData *)jarg1;
29785   if (!arg1) {
29786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29787     return 0;
29788   }
29789   {
29790     try {
29791       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29792     } catch (std::out_of_range& e) {
29793       {
29794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29795       };
29796     } catch (std::exception& e) {
29797       {
29798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29799       };
29800     } catch (Dali::DaliException e) {
29801       {
29802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29803       };
29804     } catch (...) {
29805       {
29806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29807       };
29808     }
29809   }
29810
29811   jresult = (void *)result;
29812   return jresult;
29813 }
29814
29815
29816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29817   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29818
29819   arg1 = (Dali::TouchData *)jarg1;
29820   {
29821     try {
29822       delete arg1;
29823     } catch (std::out_of_range& e) {
29824       {
29825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29826       };
29827     } catch (std::exception& e) {
29828       {
29829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29830       };
29831     } catch (Dali::DaliException e) {
29832       {
29833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29834       };
29835     } catch (...) {
29836       {
29837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29838       };
29839     }
29840   }
29841
29842 }
29843
29844
29845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29846   void * jresult ;
29847   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29848   Dali::TouchData *arg2 = 0 ;
29849   Dali::TouchData *result = 0 ;
29850
29851   arg1 = (Dali::TouchData *)jarg1;
29852   arg2 = (Dali::TouchData *)jarg2;
29853   if (!arg2) {
29854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29855     return 0;
29856   }
29857   {
29858     try {
29859       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29860     } catch (std::out_of_range& e) {
29861       {
29862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29863       };
29864     } catch (std::exception& e) {
29865       {
29866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29867       };
29868     } catch (Dali::DaliException e) {
29869       {
29870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29871       };
29872     } catch (...) {
29873       {
29874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29875       };
29876     }
29877   }
29878
29879   jresult = (void *)result;
29880   return jresult;
29881 }
29882
29883
29884 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29885   unsigned long jresult ;
29886   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29887   unsigned long result;
29888
29889   arg1 = (Dali::TouchData *)jarg1;
29890   {
29891     try {
29892       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29893     } catch (std::out_of_range& e) {
29894       {
29895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29896       };
29897     } catch (std::exception& e) {
29898       {
29899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29900       };
29901     } catch (Dali::DaliException e) {
29902       {
29903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29904       };
29905     } catch (...) {
29906       {
29907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29908       };
29909     }
29910   }
29911
29912   jresult = (unsigned long)result;
29913   return jresult;
29914 }
29915
29916
29917 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29918   unsigned long jresult ;
29919   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29920   std::size_t result;
29921
29922   arg1 = (Dali::TouchData *)jarg1;
29923   {
29924     try {
29925       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29926     } catch (std::out_of_range& e) {
29927       {
29928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29929       };
29930     } catch (std::exception& e) {
29931       {
29932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29933       };
29934     } catch (Dali::DaliException e) {
29935       {
29936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29937       };
29938     } catch (...) {
29939       {
29940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29941       };
29942     }
29943   }
29944
29945   jresult = (unsigned long)result;
29946   return jresult;
29947 }
29948
29949
29950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29951   int jresult ;
29952   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29953   std::size_t arg2 ;
29954   int32_t result;
29955
29956   arg1 = (Dali::TouchData *)jarg1;
29957   arg2 = (std::size_t)jarg2;
29958   {
29959     try {
29960       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29961     } catch (std::out_of_range& e) {
29962       {
29963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29964       };
29965     } catch (std::exception& e) {
29966       {
29967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29968       };
29969     } catch (Dali::DaliException e) {
29970       {
29971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29972       };
29973     } catch (...) {
29974       {
29975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29976       };
29977     }
29978   }
29979
29980   jresult = result;
29981   return jresult;
29982 }
29983
29984
29985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29986   int jresult ;
29987   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29988   std::size_t arg2 ;
29989   Dali::PointState::Type result;
29990
29991   arg1 = (Dali::TouchData *)jarg1;
29992   arg2 = (std::size_t)jarg2;
29993   {
29994     try {
29995       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29996     } catch (std::out_of_range& e) {
29997       {
29998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29999       };
30000     } catch (std::exception& e) {
30001       {
30002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30003       };
30004     } catch (Dali::DaliException e) {
30005       {
30006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30007       };
30008     } catch (...) {
30009       {
30010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30011       };
30012     }
30013   }
30014
30015   jresult = (int)result;
30016   return jresult;
30017 }
30018
30019
30020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
30021   void * jresult ;
30022   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30023   std::size_t arg2 ;
30024   Dali::Actor result;
30025
30026   arg1 = (Dali::TouchData *)jarg1;
30027   arg2 = (std::size_t)jarg2;
30028   {
30029     try {
30030       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
30031     } catch (std::out_of_range& e) {
30032       {
30033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30034       };
30035     } catch (std::exception& e) {
30036       {
30037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30038       };
30039     } catch (Dali::DaliException e) {
30040       {
30041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30042       };
30043     } catch (...) {
30044       {
30045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30046       };
30047     }
30048   }
30049
30050   jresult = new Dali::Actor((const Dali::Actor &)result);
30051   return jresult;
30052 }
30053
30054
30055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30056   void * jresult ;
30057   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30058   std::size_t arg2 ;
30059   Dali::Vector2 *result = 0 ;
30060
30061   arg1 = (Dali::TouchData *)jarg1;
30062   arg2 = (std::size_t)jarg2;
30063   {
30064     try {
30065       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30066     } catch (std::out_of_range& e) {
30067       {
30068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30069       };
30070     } catch (std::exception& e) {
30071       {
30072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30073       };
30074     } catch (Dali::DaliException e) {
30075       {
30076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30077       };
30078     } catch (...) {
30079       {
30080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30081       };
30082     }
30083   }
30084
30085   jresult = (void *)result;
30086   return jresult;
30087 }
30088
30089
30090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30091   void * jresult ;
30092   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30093   std::size_t arg2 ;
30094   Dali::Vector2 *result = 0 ;
30095
30096   arg1 = (Dali::TouchData *)jarg1;
30097   arg2 = (std::size_t)jarg2;
30098   {
30099     try {
30100       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30101     } catch (std::out_of_range& e) {
30102       {
30103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30104       };
30105     } catch (std::exception& e) {
30106       {
30107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30108       };
30109     } catch (Dali::DaliException e) {
30110       {
30111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30112       };
30113     } catch (...) {
30114       {
30115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30116       };
30117     }
30118   }
30119
30120   jresult = (void *)result;
30121   return jresult;
30122 }
30123
30124
30125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30126   float jresult ;
30127   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30128   std::size_t arg2 ;
30129   float result;
30130
30131   arg1 = (Dali::TouchData *)jarg1;
30132   arg2 = (std::size_t)jarg2;
30133   {
30134     try {
30135       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30136     } catch (std::out_of_range& e) {
30137       {
30138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30139       };
30140     } catch (std::exception& e) {
30141       {
30142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30143       };
30144     } catch (Dali::DaliException e) {
30145       {
30146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30147       };
30148     } catch (...) {
30149       {
30150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30151       };
30152     }
30153   }
30154
30155   jresult = result;
30156   return jresult;
30157 }
30158
30159
30160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30161   void * jresult ;
30162   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30163   std::size_t arg2 ;
30164   Dali::Vector2 *result = 0 ;
30165
30166   arg1 = (Dali::TouchData *)jarg1;
30167   arg2 = (std::size_t)jarg2;
30168   {
30169     try {
30170       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30171     } catch (std::out_of_range& e) {
30172       {
30173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30174       };
30175     } catch (std::exception& e) {
30176       {
30177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30178       };
30179     } catch (Dali::DaliException e) {
30180       {
30181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30182       };
30183     } catch (...) {
30184       {
30185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30186       };
30187     }
30188   }
30189
30190   jresult = (void *)result;
30191   return jresult;
30192 }
30193
30194
30195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30196   float jresult ;
30197   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30198   std::size_t arg2 ;
30199   float result;
30200
30201   arg1 = (Dali::TouchData *)jarg1;
30202   arg2 = (std::size_t)jarg2;
30203   {
30204     try {
30205       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30206     } catch (std::out_of_range& e) {
30207       {
30208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30209       };
30210     } catch (std::exception& e) {
30211       {
30212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30213       };
30214     } catch (Dali::DaliException e) {
30215       {
30216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30217       };
30218     } catch (...) {
30219       {
30220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30221       };
30222     }
30223   }
30224
30225   jresult = result;
30226   return jresult;
30227 }
30228
30229
30230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30231   void * jresult ;
30232   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30233   std::size_t arg2 ;
30234   Dali::Degree result;
30235
30236   arg1 = (Dali::TouchData *)jarg1;
30237   arg2 = (std::size_t)jarg2;
30238   {
30239     try {
30240       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30241     } catch (std::out_of_range& e) {
30242       {
30243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30244       };
30245     } catch (std::exception& e) {
30246       {
30247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30248       };
30249     } catch (Dali::DaliException e) {
30250       {
30251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30252       };
30253     } catch (...) {
30254       {
30255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30256       };
30257     }
30258   }
30259
30260   jresult = new Dali::Degree((const Dali::Degree &)result);
30261   return jresult;
30262 }
30263
30264
30265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30266   int jresult ;
30267   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30268   std::size_t arg2 ;
30269   Dali::MouseButton::Type result;
30270
30271   arg1 = (Dali::TouchData *)jarg1;
30272   arg2 = (std::size_t)jarg2;
30273   {
30274     try {
30275       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30276     } catch (std::out_of_range& e) {
30277       {
30278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30279       };
30280     } catch (std::exception& e) {
30281       {
30282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30283       };
30284     } catch (Dali::DaliException e) {
30285       {
30286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30287       };
30288     } catch (...) {
30289       {
30290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30291       };
30292     }
30293   }
30294
30295   jresult = static_cast< int >(result);
30296   return jresult;
30297 }
30298
30299
30300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30301   void * jresult ;
30302   Dali::GestureDetector *result = 0 ;
30303
30304   {
30305     try {
30306       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30307     } catch (std::out_of_range& e) {
30308       {
30309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30310       };
30311     } catch (std::exception& e) {
30312       {
30313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30314       };
30315     } catch (Dali::DaliException e) {
30316       {
30317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30318       };
30319     } catch (...) {
30320       {
30321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30322       };
30323     }
30324   }
30325
30326   jresult = (void *)result;
30327   return jresult;
30328 }
30329
30330
30331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30332   void * jresult ;
30333   Dali::BaseHandle arg1 ;
30334   Dali::BaseHandle *argp1 ;
30335   Dali::GestureDetector result;
30336
30337   argp1 = (Dali::BaseHandle *)jarg1;
30338   if (!argp1) {
30339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30340     return 0;
30341   }
30342   arg1 = *argp1;
30343   {
30344     try {
30345       result = Dali::GestureDetector::DownCast(arg1);
30346     } catch (std::out_of_range& e) {
30347       {
30348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30349       };
30350     } catch (std::exception& e) {
30351       {
30352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30353       };
30354     } catch (Dali::DaliException e) {
30355       {
30356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30357       };
30358     } catch (...) {
30359       {
30360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30361       };
30362     }
30363   }
30364
30365   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30366   return jresult;
30367 }
30368
30369
30370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30371   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30372
30373   arg1 = (Dali::GestureDetector *)jarg1;
30374   {
30375     try {
30376       delete arg1;
30377     } catch (std::out_of_range& e) {
30378       {
30379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30380       };
30381     } catch (std::exception& e) {
30382       {
30383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30384       };
30385     } catch (Dali::DaliException e) {
30386       {
30387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30388       };
30389     } catch (...) {
30390       {
30391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30392       };
30393     }
30394   }
30395
30396 }
30397
30398
30399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30400   void * jresult ;
30401   Dali::GestureDetector *arg1 = 0 ;
30402   Dali::GestureDetector *result = 0 ;
30403
30404   arg1 = (Dali::GestureDetector *)jarg1;
30405   if (!arg1) {
30406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30407     return 0;
30408   }
30409   {
30410     try {
30411       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30412     } catch (std::out_of_range& e) {
30413       {
30414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30415       };
30416     } catch (std::exception& e) {
30417       {
30418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30419       };
30420     } catch (Dali::DaliException e) {
30421       {
30422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30423       };
30424     } catch (...) {
30425       {
30426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30427       };
30428     }
30429   }
30430
30431   jresult = (void *)result;
30432   return jresult;
30433 }
30434
30435
30436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30437   void * jresult ;
30438   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30439   Dali::GestureDetector *arg2 = 0 ;
30440   Dali::GestureDetector *result = 0 ;
30441
30442   arg1 = (Dali::GestureDetector *)jarg1;
30443   arg2 = (Dali::GestureDetector *)jarg2;
30444   if (!arg2) {
30445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30446     return 0;
30447   }
30448   {
30449     try {
30450       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30451     } catch (std::out_of_range& e) {
30452       {
30453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30454       };
30455     } catch (std::exception& e) {
30456       {
30457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30458       };
30459     } catch (Dali::DaliException e) {
30460       {
30461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30462       };
30463     } catch (...) {
30464       {
30465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30466       };
30467     }
30468   }
30469
30470   jresult = (void *)result;
30471   return jresult;
30472 }
30473
30474
30475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30476   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30477   Dali::Actor arg2 ;
30478   Dali::Actor *argp2 ;
30479
30480   arg1 = (Dali::GestureDetector *)jarg1;
30481   argp2 = (Dali::Actor *)jarg2;
30482   if (!argp2) {
30483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30484     return ;
30485   }
30486   arg2 = *argp2;
30487   {
30488     try {
30489       (arg1)->Attach(arg2);
30490     } catch (std::out_of_range& e) {
30491       {
30492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30493       };
30494     } catch (std::exception& e) {
30495       {
30496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30497       };
30498     } catch (Dali::DaliException e) {
30499       {
30500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30501       };
30502     } catch (...) {
30503       {
30504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30505       };
30506     }
30507   }
30508
30509 }
30510
30511
30512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30513   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30514   Dali::Actor arg2 ;
30515   Dali::Actor *argp2 ;
30516
30517   arg1 = (Dali::GestureDetector *)jarg1;
30518   argp2 = (Dali::Actor *)jarg2;
30519   if (!argp2) {
30520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30521     return ;
30522   }
30523   arg2 = *argp2;
30524   {
30525     try {
30526       (arg1)->Detach(arg2);
30527     } catch (std::out_of_range& e) {
30528       {
30529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30530       };
30531     } catch (std::exception& e) {
30532       {
30533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30534       };
30535     } catch (Dali::DaliException e) {
30536       {
30537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30538       };
30539     } catch (...) {
30540       {
30541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30542       };
30543     }
30544   }
30545
30546 }
30547
30548
30549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30550   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30551
30552   arg1 = (Dali::GestureDetector *)jarg1;
30553   {
30554     try {
30555       (arg1)->DetachAll();
30556     } catch (std::out_of_range& e) {
30557       {
30558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30559       };
30560     } catch (std::exception& e) {
30561       {
30562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30563       };
30564     } catch (Dali::DaliException e) {
30565       {
30566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30567       };
30568     } catch (...) {
30569       {
30570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30571       };
30572     }
30573   }
30574
30575 }
30576
30577
30578 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30579   unsigned long jresult ;
30580   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30581   size_t result;
30582
30583   arg1 = (Dali::GestureDetector *)jarg1;
30584   {
30585     try {
30586       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30587     } catch (std::out_of_range& e) {
30588       {
30589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30590       };
30591     } catch (std::exception& e) {
30592       {
30593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30594       };
30595     } catch (Dali::DaliException e) {
30596       {
30597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30598       };
30599     } catch (...) {
30600       {
30601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30602       };
30603     }
30604   }
30605
30606   jresult = (unsigned long)result;
30607   return jresult;
30608 }
30609
30610
30611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30612   void * jresult ;
30613   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30614   size_t arg2 ;
30615   Dali::Actor result;
30616
30617   arg1 = (Dali::GestureDetector *)jarg1;
30618   arg2 = (size_t)jarg2;
30619   {
30620     try {
30621       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30622     } catch (std::out_of_range& e) {
30623       {
30624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30625       };
30626     } catch (std::exception& e) {
30627       {
30628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30629       };
30630     } catch (Dali::DaliException e) {
30631       {
30632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30633       };
30634     } catch (...) {
30635       {
30636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30637       };
30638     }
30639   }
30640
30641   jresult = new Dali::Actor((const Dali::Actor &)result);
30642   return jresult;
30643 }
30644
30645
30646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30647   void * jresult ;
30648   Dali::Gesture *arg1 = 0 ;
30649   Dali::Gesture *result = 0 ;
30650
30651   arg1 = (Dali::Gesture *)jarg1;
30652   if (!arg1) {
30653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30654     return 0;
30655   }
30656   {
30657     try {
30658       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30659     } catch (std::out_of_range& e) {
30660       {
30661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30662       };
30663     } catch (std::exception& e) {
30664       {
30665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30666       };
30667     } catch (Dali::DaliException e) {
30668       {
30669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30670       };
30671     } catch (...) {
30672       {
30673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30674       };
30675     }
30676   }
30677
30678   jresult = (void *)result;
30679   return jresult;
30680 }
30681
30682
30683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30684   void * jresult ;
30685   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30686   Dali::Gesture *arg2 = 0 ;
30687   Dali::Gesture *result = 0 ;
30688
30689   arg1 = (Dali::Gesture *)jarg1;
30690   arg2 = (Dali::Gesture *)jarg2;
30691   if (!arg2) {
30692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30693     return 0;
30694   }
30695   {
30696     try {
30697       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30698     } catch (std::out_of_range& e) {
30699       {
30700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30701       };
30702     } catch (std::exception& e) {
30703       {
30704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30705       };
30706     } catch (Dali::DaliException e) {
30707       {
30708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30709       };
30710     } catch (...) {
30711       {
30712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30713       };
30714     }
30715   }
30716
30717   jresult = (void *)result;
30718   return jresult;
30719 }
30720
30721
30722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30723   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30724
30725   arg1 = (Dali::Gesture *)jarg1;
30726   {
30727     try {
30728       delete arg1;
30729     } catch (std::out_of_range& e) {
30730       {
30731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30732       };
30733     } catch (std::exception& e) {
30734       {
30735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30736       };
30737     } catch (Dali::DaliException e) {
30738       {
30739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30740       };
30741     } catch (...) {
30742       {
30743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30744       };
30745     }
30746   }
30747
30748 }
30749
30750
30751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30752   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30753   Dali::Gesture::Type arg2 ;
30754
30755   arg1 = (Dali::Gesture *)jarg1;
30756   arg2 = (Dali::Gesture::Type)jarg2;
30757   if (arg1) (arg1)->type = arg2;
30758 }
30759
30760
30761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30762   int jresult ;
30763   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30764   Dali::Gesture::Type result;
30765
30766   arg1 = (Dali::Gesture *)jarg1;
30767   result = (Dali::Gesture::Type) ((arg1)->type);
30768   jresult = (int)result;
30769   return jresult;
30770 }
30771
30772
30773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30774   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30775   Dali::Gesture::State arg2 ;
30776
30777   arg1 = (Dali::Gesture *)jarg1;
30778   arg2 = (Dali::Gesture::State)jarg2;
30779   if (arg1) (arg1)->state = arg2;
30780 }
30781
30782
30783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30784   int jresult ;
30785   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30786   Dali::Gesture::State result;
30787
30788   arg1 = (Dali::Gesture *)jarg1;
30789   result = (Dali::Gesture::State) ((arg1)->state);
30790   jresult = (int)result;
30791   return jresult;
30792 }
30793
30794
30795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30796   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30797   unsigned int arg2 ;
30798
30799   arg1 = (Dali::Gesture *)jarg1;
30800   arg2 = (unsigned int)jarg2;
30801   if (arg1) (arg1)->time = arg2;
30802 }
30803
30804
30805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30806   unsigned int jresult ;
30807   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30808   unsigned int result;
30809
30810   arg1 = (Dali::Gesture *)jarg1;
30811   result = (unsigned int) ((arg1)->time);
30812   jresult = result;
30813   return jresult;
30814 }
30815
30816
30817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30818   void * jresult ;
30819   Dali::HoverEvent *result = 0 ;
30820
30821   {
30822     try {
30823       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30824     } catch (std::out_of_range& e) {
30825       {
30826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30827       };
30828     } catch (std::exception& e) {
30829       {
30830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30831       };
30832     } catch (Dali::DaliException e) {
30833       {
30834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30835       };
30836     } catch (...) {
30837       {
30838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30839       };
30840     }
30841   }
30842
30843   jresult = (void *)result;
30844   return jresult;
30845 }
30846
30847
30848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30849   void * jresult ;
30850   unsigned long arg1 ;
30851   Dali::HoverEvent *result = 0 ;
30852
30853   arg1 = (unsigned long)jarg1;
30854   {
30855     try {
30856       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30857     } catch (std::out_of_range& e) {
30858       {
30859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30860       };
30861     } catch (std::exception& e) {
30862       {
30863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30864       };
30865     } catch (Dali::DaliException e) {
30866       {
30867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30868       };
30869     } catch (...) {
30870       {
30871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30872       };
30873     }
30874   }
30875
30876   jresult = (void *)result;
30877   return jresult;
30878 }
30879
30880
30881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30882   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30883
30884   arg1 = (Dali::HoverEvent *)jarg1;
30885   {
30886     try {
30887       delete arg1;
30888     } catch (std::out_of_range& e) {
30889       {
30890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30891       };
30892     } catch (std::exception& e) {
30893       {
30894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30895       };
30896     } catch (Dali::DaliException e) {
30897       {
30898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30899       };
30900     } catch (...) {
30901       {
30902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30903       };
30904     }
30905   }
30906
30907 }
30908
30909
30910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30911   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30912   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30913
30914   arg1 = (Dali::HoverEvent *)jarg1;
30915   arg2 = (Dali::TouchPointContainer *)jarg2;
30916   if (arg1) (arg1)->points = *arg2;
30917 }
30918
30919
30920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30921   void * jresult ;
30922   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30923   Dali::TouchPointContainer *result = 0 ;
30924
30925   arg1 = (Dali::HoverEvent *)jarg1;
30926   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30927   jresult = (void *)result;
30928   return jresult;
30929 }
30930
30931
30932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30933   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30934   unsigned long arg2 ;
30935
30936   arg1 = (Dali::HoverEvent *)jarg1;
30937   arg2 = (unsigned long)jarg2;
30938   if (arg1) (arg1)->time = arg2;
30939 }
30940
30941
30942 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30943   unsigned long jresult ;
30944   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30945   unsigned long result;
30946
30947   arg1 = (Dali::HoverEvent *)jarg1;
30948   result = (unsigned long) ((arg1)->time);
30949   jresult = (unsigned long)result;
30950   return jresult;
30951 }
30952
30953
30954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30955   unsigned int jresult ;
30956   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30957   unsigned int result;
30958
30959   arg1 = (Dali::HoverEvent *)jarg1;
30960   {
30961     try {
30962       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30963     } catch (std::out_of_range& e) {
30964       {
30965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30966       };
30967     } catch (std::exception& e) {
30968       {
30969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30970       };
30971     } catch (Dali::DaliException e) {
30972       {
30973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30974       };
30975     } catch (...) {
30976       {
30977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30978       };
30979     }
30980   }
30981
30982   jresult = result;
30983   return jresult;
30984 }
30985
30986
30987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30988   void * jresult ;
30989   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30990   unsigned int arg2 ;
30991   Dali::TouchPoint *result = 0 ;
30992
30993   arg1 = (Dali::HoverEvent *)jarg1;
30994   arg2 = (unsigned int)jarg2;
30995   {
30996     try {
30997       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30998     } catch (std::out_of_range& e) {
30999       {
31000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31001       };
31002     } catch (std::exception& e) {
31003       {
31004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31005       };
31006     } catch (Dali::DaliException e) {
31007       {
31008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31009       };
31010     } catch (...) {
31011       {
31012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31013       };
31014     }
31015   }
31016
31017   jresult = (void *)result;
31018   return jresult;
31019 }
31020
31021
31022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
31023   void * jresult ;
31024   Dali::KeyEvent *result = 0 ;
31025
31026   {
31027     try {
31028       result = (Dali::KeyEvent *)new Dali::KeyEvent();
31029     } catch (std::out_of_range& e) {
31030       {
31031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31032       };
31033     } catch (std::exception& e) {
31034       {
31035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31036       };
31037     } catch (Dali::DaliException e) {
31038       {
31039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31040       };
31041     } catch (...) {
31042       {
31043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31044       };
31045     }
31046   }
31047
31048   jresult = (void *)result;
31049   return jresult;
31050 }
31051
31052
31053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31054   void * jresult ;
31055   std::string *arg1 = 0 ;
31056   std::string *arg2 = 0 ;
31057   int arg3 ;
31058   int arg4 ;
31059   unsigned long arg5 ;
31060   Dali::KeyEvent::State *arg6 = 0 ;
31061   Dali::KeyEvent::State temp6 ;
31062   Dali::KeyEvent *result = 0 ;
31063
31064   if (!jarg1) {
31065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31066     return 0;
31067   }
31068   std::string arg1_str(jarg1);
31069   arg1 = &arg1_str;
31070   if (!jarg2) {
31071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31072     return 0;
31073   }
31074   std::string arg2_str(jarg2);
31075   arg2 = &arg2_str;
31076   arg3 = (int)jarg3;
31077   arg4 = (int)jarg4;
31078   arg5 = (unsigned long)jarg5;
31079   temp6 = (Dali::KeyEvent::State)jarg6;
31080   arg6 = &temp6;
31081   {
31082     try {
31083       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31084     } catch (std::out_of_range& e) {
31085       {
31086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31087       };
31088     } catch (std::exception& e) {
31089       {
31090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31091       };
31092     } catch (Dali::DaliException e) {
31093       {
31094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31095       };
31096     } catch (...) {
31097       {
31098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31099       };
31100     }
31101   }
31102
31103   jresult = (void *)result;
31104
31105   //argout typemap for const std::string&
31106
31107
31108   //argout typemap for const std::string&
31109
31110   return jresult;
31111 }
31112
31113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31114   void * jresult ;
31115   Dali::KeyEvent *arg1 = 0 ;
31116   Dali::KeyEvent *result = 0 ;
31117
31118   arg1 = (Dali::KeyEvent *)jarg1;
31119   if (!arg1) {
31120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31121     return 0;
31122   }
31123   {
31124     try {
31125       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31126     } catch (std::out_of_range& e) {
31127       {
31128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31129       };
31130     } catch (std::exception& e) {
31131       {
31132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31133       };
31134     } catch (Dali::DaliException e) {
31135       {
31136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31137       };
31138     } catch (...) {
31139       {
31140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31141       };
31142     }
31143   }
31144
31145   jresult = (void *)result;
31146   return jresult;
31147 }
31148
31149
31150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31151   void * jresult ;
31152   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31153   Dali::KeyEvent *arg2 = 0 ;
31154   Dali::KeyEvent *result = 0 ;
31155
31156   arg1 = (Dali::KeyEvent *)jarg1;
31157   arg2 = (Dali::KeyEvent *)jarg2;
31158   if (!arg2) {
31159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31160     return 0;
31161   }
31162   {
31163     try {
31164       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31165     } catch (std::out_of_range& e) {
31166       {
31167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31168       };
31169     } catch (std::exception& e) {
31170       {
31171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31172       };
31173     } catch (Dali::DaliException e) {
31174       {
31175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31176       };
31177     } catch (...) {
31178       {
31179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31180       };
31181     }
31182   }
31183
31184   jresult = (void *)result;
31185   return jresult;
31186 }
31187
31188
31189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31190   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31191
31192   arg1 = (Dali::KeyEvent *)jarg1;
31193   {
31194     try {
31195       delete arg1;
31196     } catch (std::out_of_range& e) {
31197       {
31198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31199       };
31200     } catch (std::exception& e) {
31201       {
31202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31203       };
31204     } catch (Dali::DaliException e) {
31205       {
31206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31207       };
31208     } catch (...) {
31209       {
31210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31211       };
31212     }
31213   }
31214
31215 }
31216
31217
31218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31219   unsigned int jresult ;
31220   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31221   bool result;
31222
31223   arg1 = (Dali::KeyEvent *)jarg1;
31224   {
31225     try {
31226       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31227     } catch (std::out_of_range& e) {
31228       {
31229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31230       };
31231     } catch (std::exception& e) {
31232       {
31233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31234       };
31235     } catch (Dali::DaliException e) {
31236       {
31237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31238       };
31239     } catch (...) {
31240       {
31241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31242       };
31243     }
31244   }
31245
31246   jresult = result;
31247   return jresult;
31248 }
31249
31250
31251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31252   unsigned int jresult ;
31253   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31254   bool result;
31255
31256   arg1 = (Dali::KeyEvent *)jarg1;
31257   {
31258     try {
31259       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31260     } catch (std::out_of_range& e) {
31261       {
31262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31263       };
31264     } catch (std::exception& e) {
31265       {
31266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31267       };
31268     } catch (Dali::DaliException e) {
31269       {
31270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31271       };
31272     } catch (...) {
31273       {
31274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31275       };
31276     }
31277   }
31278
31279   jresult = result;
31280   return jresult;
31281 }
31282
31283
31284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31285   unsigned int jresult ;
31286   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31287   bool result;
31288
31289   arg1 = (Dali::KeyEvent *)jarg1;
31290   {
31291     try {
31292       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31293     } catch (std::out_of_range& e) {
31294       {
31295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31296       };
31297     } catch (std::exception& e) {
31298       {
31299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31300       };
31301     } catch (Dali::DaliException e) {
31302       {
31303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31304       };
31305     } catch (...) {
31306       {
31307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31308       };
31309     }
31310   }
31311
31312   jresult = result;
31313   return jresult;
31314 }
31315
31316
31317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31318   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31319   std::string *arg2 = 0 ;
31320
31321   arg1 = (Dali::KeyEvent *)jarg1;
31322   if (!jarg2) {
31323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31324     return ;
31325   }
31326   std::string arg2_str(jarg2);
31327   arg2 = &arg2_str;
31328   if (arg1) (arg1)->keyPressedName = *arg2;
31329
31330   //argout typemap for const std::string&
31331
31332 }
31333
31334
31335 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31336   char * jresult ;
31337
31338   if( jarg1 == NULL )
31339   {
31340     jresult = SWIG_csharp_string_callback( "" );
31341   }
31342   else
31343   {
31344     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31345     std::string *result = 0;
31346
31347     arg1 = ( Dali::KeyEvent * )jarg1;
31348     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31349     jresult = SWIG_csharp_string_callback( result->c_str() );
31350   }
31351
31352   return jresult;
31353 }
31354
31355
31356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31357   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31358   std::string *arg2 = 0 ;
31359
31360   arg1 = (Dali::KeyEvent *)jarg1;
31361   if (!jarg2) {
31362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31363     return ;
31364   }
31365   std::string arg2_str(jarg2);
31366   arg2 = &arg2_str;
31367   if (arg1) (arg1)->keyPressed = *arg2;
31368
31369   //argout typemap for const std::string&
31370
31371 }
31372
31373
31374 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31375   char * jresult ;
31376   if( NULL == jarg1 )
31377   {
31378     jresult = SWIG_csharp_string_callback( "" );
31379   }
31380   else
31381   {
31382     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31383     std::string *result = 0;
31384
31385     arg1 = ( Dali::KeyEvent * )jarg1;
31386     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31387     jresult = SWIG_csharp_string_callback( result->c_str() );
31388   }
31389   return jresult;
31390 }
31391
31392
31393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31394   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31395   int arg2 ;
31396
31397   arg1 = (Dali::KeyEvent *)jarg1;
31398   arg2 = (int)jarg2;
31399   if (arg1) (arg1)->keyCode = arg2;
31400 }
31401
31402
31403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31404   int jresult ;
31405   if( NULL == jarg1 )
31406   {
31407     jresult = -1;
31408   }
31409   else
31410   {
31411     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31412     int result;
31413
31414     arg1 = ( Dali::KeyEvent * )jarg1;
31415     result = (int)( ( arg1 )->keyCode );
31416     jresult = result;
31417   }
31418   return jresult;
31419 }
31420
31421
31422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31423   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31424   int arg2 ;
31425
31426   arg1 = (Dali::KeyEvent *)jarg1;
31427   arg2 = (int)jarg2;
31428   if (arg1) (arg1)->keyModifier = arg2;
31429 }
31430
31431
31432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31433   int jresult ;
31434   if( jarg1 == NULL )
31435   {
31436     jresult = -1;
31437   }
31438   else
31439   {
31440     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31441     int result;
31442
31443     arg1 = ( Dali::KeyEvent * )jarg1;
31444     result = (int)( ( arg1 )->keyModifier );
31445     jresult = result;
31446   }
31447   return jresult;
31448 }
31449
31450
31451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31452   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31453   unsigned long arg2 ;
31454
31455   arg1 = (Dali::KeyEvent *)jarg1;
31456   arg2 = (unsigned long)jarg2;
31457   if (arg1) (arg1)->time = arg2;
31458 }
31459
31460
31461 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31462   unsigned long jresult ;
31463   if( jarg1 == NULL )
31464   {
31465     jresult = 0;
31466   }
31467   else
31468   {
31469     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31470     unsigned long result;
31471
31472     arg1 = ( Dali::KeyEvent * )jarg1;
31473     result = (unsigned long)( ( arg1 )->time );
31474     jresult = (unsigned long)result;
31475   }
31476   return jresult;
31477 }
31478
31479
31480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31481   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31482   Dali::KeyEvent::State arg2 ;
31483
31484   arg1 = (Dali::KeyEvent *)jarg1;
31485   arg2 = (Dali::KeyEvent::State)jarg2;
31486   if (arg1) (arg1)->state = arg2;
31487 }
31488
31489
31490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31491   int jresult ;
31492   if( jarg1 == NULL )
31493   {
31494     jresult = -1;
31495   }
31496   else
31497   {
31498     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31499     Dali::KeyEvent::State result;
31500
31501     arg1 = ( Dali::KeyEvent * )jarg1;
31502     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31503     jresult = (int)result;
31504   }
31505   return jresult;
31506 }
31507
31508 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31509   char * jresult ;
31510   std::string result;
31511   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31512
31513   arg1 = (Dali::KeyEvent *)jarg1;
31514   if (!arg1) {
31515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31516     return 0;
31517   }
31518   {
31519     try {
31520       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31521     } catch (std::out_of_range& e) {
31522       {
31523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31524       };
31525     } catch (std::exception& e) {
31526       {
31527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31528       };
31529     } catch (Dali::DaliException e) {
31530       {
31531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31532       };
31533     } catch (...) {
31534       {
31535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31536       };
31537     }
31538
31539   }
31540
31541   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31542   return jresult;
31543 }
31544
31545
31546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31547   void * jresult ;
31548   Dali::LongPressGestureDetector *result = 0 ;
31549
31550   {
31551     try {
31552       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31553     } catch (std::out_of_range& e) {
31554       {
31555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31556       };
31557     } catch (std::exception& e) {
31558       {
31559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31560       };
31561     } catch (Dali::DaliException e) {
31562       {
31563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31564       };
31565     } catch (...) {
31566       {
31567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31568       };
31569     }
31570   }
31571
31572   jresult = (void *)result;
31573   return jresult;
31574 }
31575
31576
31577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31578   void * jresult ;
31579   Dali::LongPressGestureDetector result;
31580
31581   {
31582     try {
31583       result = Dali::LongPressGestureDetector::New();
31584     } catch (std::out_of_range& e) {
31585       {
31586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31587       };
31588     } catch (std::exception& e) {
31589       {
31590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31591       };
31592     } catch (Dali::DaliException e) {
31593       {
31594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31595       };
31596     } catch (...) {
31597       {
31598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31599       };
31600     }
31601   }
31602
31603   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31604   return jresult;
31605 }
31606
31607
31608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31609   void * jresult ;
31610   unsigned int arg1 ;
31611   Dali::LongPressGestureDetector result;
31612
31613   arg1 = (unsigned int)jarg1;
31614   {
31615     try {
31616       result = Dali::LongPressGestureDetector::New(arg1);
31617     } catch (std::out_of_range& e) {
31618       {
31619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31620       };
31621     } catch (std::exception& e) {
31622       {
31623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31624       };
31625     } catch (Dali::DaliException e) {
31626       {
31627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31628       };
31629     } catch (...) {
31630       {
31631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31632       };
31633     }
31634   }
31635
31636   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31637   return jresult;
31638 }
31639
31640
31641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31642   void * jresult ;
31643   unsigned int arg1 ;
31644   unsigned int arg2 ;
31645   Dali::LongPressGestureDetector result;
31646
31647   arg1 = (unsigned int)jarg1;
31648   arg2 = (unsigned int)jarg2;
31649   {
31650     try {
31651       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31652     } catch (std::out_of_range& e) {
31653       {
31654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31655       };
31656     } catch (std::exception& e) {
31657       {
31658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31659       };
31660     } catch (Dali::DaliException e) {
31661       {
31662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31663       };
31664     } catch (...) {
31665       {
31666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31667       };
31668     }
31669   }
31670
31671   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31672   return jresult;
31673 }
31674
31675
31676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31677   void * jresult ;
31678   Dali::BaseHandle arg1 ;
31679   Dali::BaseHandle *argp1 ;
31680   Dali::LongPressGestureDetector result;
31681
31682   argp1 = (Dali::BaseHandle *)jarg1;
31683   if (!argp1) {
31684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31685     return 0;
31686   }
31687   arg1 = *argp1;
31688   {
31689     try {
31690       result = Dali::LongPressGestureDetector::DownCast(arg1);
31691     } catch (std::out_of_range& e) {
31692       {
31693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31694       };
31695     } catch (std::exception& e) {
31696       {
31697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31698       };
31699     } catch (Dali::DaliException e) {
31700       {
31701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31702       };
31703     } catch (...) {
31704       {
31705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31706       };
31707     }
31708   }
31709
31710   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31711   return jresult;
31712 }
31713
31714
31715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31716   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31717
31718   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31719   {
31720     try {
31721       delete arg1;
31722     } catch (std::out_of_range& e) {
31723       {
31724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31725       };
31726     } catch (std::exception& e) {
31727       {
31728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31729       };
31730     } catch (Dali::DaliException e) {
31731       {
31732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31733       };
31734     } catch (...) {
31735       {
31736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31737       };
31738     }
31739   }
31740
31741 }
31742
31743
31744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31745   void * jresult ;
31746   Dali::LongPressGestureDetector *arg1 = 0 ;
31747   Dali::LongPressGestureDetector *result = 0 ;
31748
31749   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31750   if (!arg1) {
31751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31752     return 0;
31753   }
31754   {
31755     try {
31756       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31757     } catch (std::out_of_range& e) {
31758       {
31759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31760       };
31761     } catch (std::exception& e) {
31762       {
31763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31764       };
31765     } catch (Dali::DaliException e) {
31766       {
31767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31768       };
31769     } catch (...) {
31770       {
31771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31772       };
31773     }
31774   }
31775
31776   jresult = (void *)result;
31777   return jresult;
31778 }
31779
31780
31781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31782   void * jresult ;
31783   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31784   Dali::LongPressGestureDetector *arg2 = 0 ;
31785   Dali::LongPressGestureDetector *result = 0 ;
31786
31787   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31788   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31789   if (!arg2) {
31790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31791     return 0;
31792   }
31793   {
31794     try {
31795       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31796     } catch (std::out_of_range& e) {
31797       {
31798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31799       };
31800     } catch (std::exception& e) {
31801       {
31802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31803       };
31804     } catch (Dali::DaliException e) {
31805       {
31806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31807       };
31808     } catch (...) {
31809       {
31810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31811       };
31812     }
31813   }
31814
31815   jresult = (void *)result;
31816   return jresult;
31817 }
31818
31819
31820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31821   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31822   unsigned int arg2 ;
31823
31824   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31825   arg2 = (unsigned int)jarg2;
31826   {
31827     try {
31828       (arg1)->SetTouchesRequired(arg2);
31829     } catch (std::out_of_range& e) {
31830       {
31831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31832       };
31833     } catch (std::exception& e) {
31834       {
31835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31836       };
31837     } catch (Dali::DaliException e) {
31838       {
31839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31840       };
31841     } catch (...) {
31842       {
31843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31844       };
31845     }
31846   }
31847
31848 }
31849
31850
31851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31852   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31853   unsigned int arg2 ;
31854   unsigned int arg3 ;
31855
31856   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31857   arg2 = (unsigned int)jarg2;
31858   arg3 = (unsigned int)jarg3;
31859   {
31860     try {
31861       (arg1)->SetTouchesRequired(arg2,arg3);
31862     } catch (std::out_of_range& e) {
31863       {
31864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31865       };
31866     } catch (std::exception& e) {
31867       {
31868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31869       };
31870     } catch (Dali::DaliException e) {
31871       {
31872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31873       };
31874     } catch (...) {
31875       {
31876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31877       };
31878     }
31879   }
31880
31881 }
31882
31883
31884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31885   unsigned int jresult ;
31886   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31887   unsigned int result;
31888
31889   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31890   {
31891     try {
31892       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31893     } catch (std::out_of_range& e) {
31894       {
31895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31896       };
31897     } catch (std::exception& e) {
31898       {
31899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31900       };
31901     } catch (Dali::DaliException e) {
31902       {
31903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31904       };
31905     } catch (...) {
31906       {
31907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31908       };
31909     }
31910   }
31911
31912   jresult = result;
31913   return jresult;
31914 }
31915
31916
31917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31918   unsigned int jresult ;
31919   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31920   unsigned int result;
31921
31922   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31923   {
31924     try {
31925       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31926     } catch (std::out_of_range& e) {
31927       {
31928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31929       };
31930     } catch (std::exception& e) {
31931       {
31932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31933       };
31934     } catch (Dali::DaliException e) {
31935       {
31936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31937       };
31938     } catch (...) {
31939       {
31940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31941       };
31942     }
31943   }
31944
31945   jresult = result;
31946   return jresult;
31947 }
31948
31949
31950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31951   void * jresult ;
31952   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31953   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31954
31955   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31956   {
31957     try {
31958       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31959     } catch (std::out_of_range& e) {
31960       {
31961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31962       };
31963     } catch (std::exception& e) {
31964       {
31965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31966       };
31967     } catch (Dali::DaliException e) {
31968       {
31969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31970       };
31971     } catch (...) {
31972       {
31973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31974       };
31975     }
31976   }
31977
31978   jresult = (void *)result;
31979   return jresult;
31980 }
31981
31982
31983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31984   void * jresult ;
31985   Dali::Gesture::State arg1 ;
31986   Dali::LongPressGesture *result = 0 ;
31987
31988   arg1 = (Dali::Gesture::State)jarg1;
31989   {
31990     try {
31991       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31992     } catch (std::out_of_range& e) {
31993       {
31994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31995       };
31996     } catch (std::exception& e) {
31997       {
31998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31999       };
32000     } catch (Dali::DaliException e) {
32001       {
32002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32003       };
32004     } catch (...) {
32005       {
32006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32007       };
32008     }
32009   }
32010
32011   jresult = (void *)result;
32012   return jresult;
32013 }
32014
32015
32016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
32017   void * jresult ;
32018   Dali::LongPressGesture *arg1 = 0 ;
32019   Dali::LongPressGesture *result = 0 ;
32020
32021   arg1 = (Dali::LongPressGesture *)jarg1;
32022   if (!arg1) {
32023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32024     return 0;
32025   }
32026   {
32027     try {
32028       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
32029     } catch (std::out_of_range& e) {
32030       {
32031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32032       };
32033     } catch (std::exception& e) {
32034       {
32035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32036       };
32037     } catch (Dali::DaliException e) {
32038       {
32039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32040       };
32041     } catch (...) {
32042       {
32043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32044       };
32045     }
32046   }
32047
32048   jresult = (void *)result;
32049   return jresult;
32050 }
32051
32052
32053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
32054   void * jresult ;
32055   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32056   Dali::LongPressGesture *arg2 = 0 ;
32057   Dali::LongPressGesture *result = 0 ;
32058
32059   arg1 = (Dali::LongPressGesture *)jarg1;
32060   arg2 = (Dali::LongPressGesture *)jarg2;
32061   if (!arg2) {
32062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32063     return 0;
32064   }
32065   {
32066     try {
32067       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
32068     } catch (std::out_of_range& e) {
32069       {
32070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32071       };
32072     } catch (std::exception& e) {
32073       {
32074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32075       };
32076     } catch (Dali::DaliException e) {
32077       {
32078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32079       };
32080     } catch (...) {
32081       {
32082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32083       };
32084     }
32085   }
32086
32087   jresult = (void *)result;
32088   return jresult;
32089 }
32090
32091
32092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32093   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32094
32095   arg1 = (Dali::LongPressGesture *)jarg1;
32096   {
32097     try {
32098       delete arg1;
32099     } catch (std::out_of_range& e) {
32100       {
32101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32102       };
32103     } catch (std::exception& e) {
32104       {
32105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32106       };
32107     } catch (Dali::DaliException e) {
32108       {
32109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32110       };
32111     } catch (...) {
32112       {
32113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32114       };
32115     }
32116   }
32117
32118 }
32119
32120
32121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32122   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32123   unsigned int arg2 ;
32124
32125   arg1 = (Dali::LongPressGesture *)jarg1;
32126   arg2 = (unsigned int)jarg2;
32127   if (arg1) (arg1)->numberOfTouches = arg2;
32128 }
32129
32130
32131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32132   unsigned int jresult ;
32133   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32134   unsigned int result;
32135
32136   arg1 = (Dali::LongPressGesture *)jarg1;
32137   result = (unsigned int) ((arg1)->numberOfTouches);
32138   jresult = result;
32139   return jresult;
32140 }
32141
32142
32143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32144   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32145   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32146
32147   arg1 = (Dali::LongPressGesture *)jarg1;
32148   arg2 = (Dali::Vector2 *)jarg2;
32149   if (arg1) (arg1)->screenPoint = *arg2;
32150 }
32151
32152
32153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32154   void * jresult ;
32155   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32156   Dali::Vector2 *result = 0 ;
32157
32158   arg1 = (Dali::LongPressGesture *)jarg1;
32159   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32160   jresult = (void *)result;
32161   return jresult;
32162 }
32163
32164
32165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32166   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32167   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32168
32169   arg1 = (Dali::LongPressGesture *)jarg1;
32170   arg2 = (Dali::Vector2 *)jarg2;
32171   if (arg1) (arg1)->localPoint = *arg2;
32172 }
32173
32174
32175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32176   void * jresult ;
32177   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32178   Dali::Vector2 *result = 0 ;
32179
32180   arg1 = (Dali::LongPressGesture *)jarg1;
32181   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32182   jresult = (void *)result;
32183   return jresult;
32184 }
32185
32186
32187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32188   void * jresult ;
32189   Dali::WheelEvent *result = 0 ;
32190
32191   {
32192     try {
32193       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32194     } catch (std::out_of_range& e) {
32195       {
32196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32197       };
32198     } catch (std::exception& e) {
32199       {
32200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32201       };
32202     } catch (Dali::DaliException e) {
32203       {
32204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32205       };
32206     } catch (...) {
32207       {
32208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32209       };
32210     }
32211   }
32212
32213   jresult = (void *)result;
32214   return jresult;
32215 }
32216
32217
32218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32219   void * jresult ;
32220   Dali::WheelEvent::Type arg1 ;
32221   int arg2 ;
32222   unsigned int arg3 ;
32223   Dali::Vector2 arg4 ;
32224   int arg5 ;
32225   unsigned int arg6 ;
32226   Dali::Vector2 *argp4 ;
32227   Dali::WheelEvent *result = 0 ;
32228
32229   arg1 = (Dali::WheelEvent::Type)jarg1;
32230   arg2 = (int)jarg2;
32231   arg3 = (unsigned int)jarg3;
32232   argp4 = (Dali::Vector2 *)jarg4;
32233   if (!argp4) {
32234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32235     return 0;
32236   }
32237   arg4 = *argp4;
32238   arg5 = (int)jarg5;
32239   arg6 = (unsigned int)jarg6;
32240   {
32241     try {
32242       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32243     } catch (std::out_of_range& e) {
32244       {
32245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32246       };
32247     } catch (std::exception& e) {
32248       {
32249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32250       };
32251     } catch (Dali::DaliException e) {
32252       {
32253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32254       };
32255     } catch (...) {
32256       {
32257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32258       };
32259     }
32260   }
32261
32262   jresult = (void *)result;
32263   return jresult;
32264 }
32265
32266
32267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32268   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32269
32270   arg1 = (Dali::WheelEvent *)jarg1;
32271   {
32272     try {
32273       delete arg1;
32274     } catch (std::out_of_range& e) {
32275       {
32276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32277       };
32278     } catch (std::exception& e) {
32279       {
32280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32281       };
32282     } catch (Dali::DaliException e) {
32283       {
32284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32285       };
32286     } catch (...) {
32287       {
32288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32289       };
32290     }
32291   }
32292
32293 }
32294
32295
32296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32297   unsigned int jresult ;
32298   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32299   bool result;
32300
32301   arg1 = (Dali::WheelEvent *)jarg1;
32302   {
32303     try {
32304       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32305     } catch (std::out_of_range& e) {
32306       {
32307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32308       };
32309     } catch (std::exception& e) {
32310       {
32311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32312       };
32313     } catch (Dali::DaliException e) {
32314       {
32315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32316       };
32317     } catch (...) {
32318       {
32319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32320       };
32321     }
32322   }
32323
32324   jresult = result;
32325   return jresult;
32326 }
32327
32328
32329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32330   unsigned int jresult ;
32331   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32332   bool result;
32333
32334   arg1 = (Dali::WheelEvent *)jarg1;
32335   {
32336     try {
32337       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32338     } catch (std::out_of_range& e) {
32339       {
32340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32341       };
32342     } catch (std::exception& e) {
32343       {
32344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32345       };
32346     } catch (Dali::DaliException e) {
32347       {
32348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32349       };
32350     } catch (...) {
32351       {
32352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32353       };
32354     }
32355   }
32356
32357   jresult = result;
32358   return jresult;
32359 }
32360
32361
32362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32363   unsigned int jresult ;
32364   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32365   bool result;
32366
32367   arg1 = (Dali::WheelEvent *)jarg1;
32368   {
32369     try {
32370       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32371     } catch (std::out_of_range& e) {
32372       {
32373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32374       };
32375     } catch (std::exception& e) {
32376       {
32377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32378       };
32379     } catch (Dali::DaliException e) {
32380       {
32381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32382       };
32383     } catch (...) {
32384       {
32385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32386       };
32387     }
32388   }
32389
32390   jresult = result;
32391   return jresult;
32392 }
32393
32394
32395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32396   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32397   Dali::WheelEvent::Type arg2 ;
32398
32399   arg1 = (Dali::WheelEvent *)jarg1;
32400   arg2 = (Dali::WheelEvent::Type)jarg2;
32401   if (arg1) (arg1)->type = arg2;
32402 }
32403
32404
32405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32406   int jresult ;
32407   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32408   Dali::WheelEvent::Type result;
32409
32410   arg1 = (Dali::WheelEvent *)jarg1;
32411   result = (Dali::WheelEvent::Type) ((arg1)->type);
32412   jresult = (int)result;
32413   return jresult;
32414 }
32415
32416
32417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32418   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32419   int arg2 ;
32420
32421   arg1 = (Dali::WheelEvent *)jarg1;
32422   arg2 = (int)jarg2;
32423   if (arg1) (arg1)->direction = arg2;
32424 }
32425
32426
32427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32428   int jresult ;
32429   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32430   int result;
32431
32432   arg1 = (Dali::WheelEvent *)jarg1;
32433   result = (int) ((arg1)->direction);
32434   jresult = result;
32435   return jresult;
32436 }
32437
32438
32439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32440   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32441   unsigned int arg2 ;
32442
32443   arg1 = (Dali::WheelEvent *)jarg1;
32444   arg2 = (unsigned int)jarg2;
32445   if (arg1) (arg1)->modifiers = arg2;
32446 }
32447
32448
32449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32450   unsigned int jresult ;
32451   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32452   unsigned int result;
32453
32454   arg1 = (Dali::WheelEvent *)jarg1;
32455   result = (unsigned int) ((arg1)->modifiers);
32456   jresult = result;
32457   return jresult;
32458 }
32459
32460
32461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32462   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32463   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32464
32465   arg1 = (Dali::WheelEvent *)jarg1;
32466   arg2 = (Dali::Vector2 *)jarg2;
32467   if (arg1) (arg1)->point = *arg2;
32468 }
32469
32470
32471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32472   void * jresult ;
32473   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32474   Dali::Vector2 *result = 0 ;
32475
32476   arg1 = (Dali::WheelEvent *)jarg1;
32477   result = (Dali::Vector2 *)& ((arg1)->point);
32478   jresult = (void *)result;
32479   return jresult;
32480 }
32481
32482
32483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32484   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32485   int arg2 ;
32486
32487   arg1 = (Dali::WheelEvent *)jarg1;
32488   arg2 = (int)jarg2;
32489   if (arg1) (arg1)->z = arg2;
32490 }
32491
32492
32493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32494   int jresult ;
32495   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32496   int result;
32497
32498   arg1 = (Dali::WheelEvent *)jarg1;
32499   result = (int) ((arg1)->z);
32500   jresult = result;
32501   return jresult;
32502 }
32503
32504
32505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32506   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32507   unsigned int arg2 ;
32508
32509   arg1 = (Dali::WheelEvent *)jarg1;
32510   arg2 = (unsigned int)jarg2;
32511   if (arg1) (arg1)->timeStamp = arg2;
32512 }
32513
32514
32515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32516   unsigned int jresult ;
32517   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32518   unsigned int result;
32519
32520   arg1 = (Dali::WheelEvent *)jarg1;
32521   result = (unsigned int) ((arg1)->timeStamp);
32522   jresult = result;
32523   return jresult;
32524 }
32525
32526 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32527   char * jresult ;
32528   Dali::KeyEvent *arg1 = 0 ;
32529   std::string result;
32530
32531   arg1 = (Dali::KeyEvent *)jarg1;
32532   if (!arg1) {
32533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32534     return 0;
32535   }
32536   {
32537     try {
32538       result = arg1->GetDeviceName();
32539     } catch (std::out_of_range& e) {
32540       {
32541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32542       };
32543     } catch (std::exception& e) {
32544       {
32545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32546       };
32547     } catch (Dali::DaliException e) {
32548       {
32549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32550       };
32551     } catch (...) {
32552       {
32553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32554       };
32555     }
32556   }
32557
32558   jresult = SWIG_csharp_string_callback((&result)->c_str());
32559   return jresult;
32560 }
32561
32562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32563   int jresult ;
32564   Dali::KeyEvent *arg1 = 0 ;
32565   Dali::Device::Class::Type result;
32566
32567   arg1 = (Dali::KeyEvent *)jarg1;
32568   if (!arg1) {
32569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32570     return 0;
32571   }
32572   {
32573     try {
32574       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32575     } catch (std::out_of_range& e) {
32576       {
32577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32578       };
32579     } catch (std::exception& e) {
32580       {
32581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32582       };
32583     } catch (Dali::DaliException e) {
32584       {
32585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32586       };
32587     } catch (...) {
32588       {
32589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32590       };
32591     }
32592   }
32593
32594   jresult = (int)result;
32595   return jresult;
32596 }
32597
32598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32599   int jresult ;
32600   Dali::KeyEvent *arg1 = 0 ;
32601   Dali::Device::Subclass::Type result;
32602
32603   arg1 = (Dali::KeyEvent *)jarg1;
32604   if (!arg1) {
32605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32606     return 0;
32607   }
32608   {
32609     try {
32610       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32611     } catch (std::out_of_range& e) {
32612       {
32613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32614       };
32615     } catch (std::exception& e) {
32616       {
32617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32618       };
32619     } catch (Dali::DaliException e) {
32620       {
32621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32622       };
32623     } catch (...) {
32624       {
32625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32626       };
32627     }
32628   }
32629
32630   jresult = (int)result;
32631   return jresult;
32632 }
32633
32634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32635   Dali::Actor arg1 ;
32636   Dali::Actor *argp1 ;
32637
32638   argp1 = (Dali::Actor *)jarg1;
32639   if (!argp1) {
32640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32641     return ;
32642   }
32643   arg1 = *argp1;
32644   {
32645     try {
32646       arg1.Raise();
32647     } catch (std::out_of_range& e) {
32648       {
32649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32650       };
32651     } catch (std::exception& e) {
32652       {
32653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32654       };
32655     } catch (Dali::DaliException e) {
32656       {
32657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32658       };
32659     } catch (...) {
32660       {
32661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32662       };
32663     }
32664   }
32665
32666 }
32667
32668
32669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32670   Dali::Actor arg1 ;
32671   Dali::Actor *argp1 ;
32672
32673   argp1 = (Dali::Actor *)jarg1;
32674   if (!argp1) {
32675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32676     return ;
32677   }
32678   arg1 = *argp1;
32679   {
32680     try {
32681       arg1.Lower();
32682     } catch (std::out_of_range& e) {
32683       {
32684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32685       };
32686     } catch (std::exception& e) {
32687       {
32688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32689       };
32690     } catch (Dali::DaliException e) {
32691       {
32692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32693       };
32694     } catch (...) {
32695       {
32696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32697       };
32698     }
32699   }
32700
32701 }
32702
32703
32704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32705   Dali::Actor arg1 ;
32706   Dali::Actor *argp1 ;
32707
32708   argp1 = (Dali::Actor *)jarg1;
32709   if (!argp1) {
32710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32711     return ;
32712   }
32713   arg1 = *argp1;
32714   {
32715     try {
32716       arg1.RaiseToTop();
32717     } catch (std::out_of_range& e) {
32718       {
32719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32720       };
32721     } catch (std::exception& e) {
32722       {
32723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32724       };
32725     } catch (Dali::DaliException e) {
32726       {
32727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32728       };
32729     } catch (...) {
32730       {
32731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32732       };
32733     }
32734   }
32735
32736 }
32737
32738
32739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32740   Dali::Actor arg1 ;
32741   Dali::Actor *argp1 ;
32742
32743   argp1 = (Dali::Actor *)jarg1;
32744   if (!argp1) {
32745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32746     return ;
32747   }
32748   arg1 = *argp1;
32749   {
32750     try {
32751       arg1.LowerToBottom();
32752     } catch (std::out_of_range& e) {
32753       {
32754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32755       };
32756     } catch (std::exception& e) {
32757       {
32758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32759       };
32760     } catch (Dali::DaliException e) {
32761       {
32762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32763       };
32764     } catch (...) {
32765       {
32766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32767       };
32768     }
32769   }
32770
32771 }
32772
32773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32774   Dali::Actor arg1 ;
32775   Dali::Actor arg2 ;
32776   Dali::Actor *argp1 ;
32777   Dali::Actor *argp2 ;
32778
32779   argp1 = (Dali::Actor *)jarg1;
32780   if (!argp1) {
32781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32782     return ;
32783   }
32784   arg1 = *argp1;
32785   argp2 = (Dali::Actor *)jarg2;
32786   if (!argp2) {
32787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32788     return ;
32789   }
32790   arg2 = *argp2;
32791   {
32792     try {
32793       arg1.RaiseAbove(arg2);
32794     } catch (std::out_of_range& e) {
32795       {
32796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32797       };
32798     } catch (std::exception& e) {
32799       {
32800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32801       };
32802     } catch (Dali::DaliException e) {
32803       {
32804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32805       };
32806     } catch (...) {
32807       {
32808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32809       };
32810     }
32811   }
32812
32813 }
32814
32815
32816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32817   Dali::Actor arg1 ;
32818   Dali::Actor arg2 ;
32819   Dali::Actor *argp1 ;
32820   Dali::Actor *argp2 ;
32821
32822   argp1 = (Dali::Actor *)jarg1;
32823   if (!argp1) {
32824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32825     return ;
32826   }
32827   arg1 = *argp1;
32828   argp2 = (Dali::Actor *)jarg2;
32829   if (!argp2) {
32830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32831     return ;
32832   }
32833   arg2 = *argp2;
32834   {
32835     try {
32836       arg1.LowerBelow(arg2);
32837     } catch (std::out_of_range& e) {
32838       {
32839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32840       };
32841     } catch (std::exception& e) {
32842       {
32843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32844       };
32845     } catch (Dali::DaliException e) {
32846       {
32847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32848       };
32849     } catch (...) {
32850       {
32851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32852       };
32853     }
32854   }
32855
32856 }
32857
32858
32859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32860   void * jresult ;
32861   Dali::Actor arg1 ;
32862   Dali::Actor *argp1 ;
32863   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32864
32865   argp1 = (Dali::Actor *)jarg1;
32866   if (!argp1) {
32867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32868     return 0;
32869   }
32870   arg1 = *argp1;
32871   {
32872     try {
32873       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32874     } catch (std::out_of_range& e) {
32875       {
32876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32877       };
32878     } catch (std::exception& e) {
32879       {
32880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32881       };
32882     } catch (Dali::DaliException e) {
32883       {
32884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32885       };
32886     } catch (...) {
32887       {
32888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32889       };
32890     }
32891   }
32892
32893   jresult = (void *)result;
32894   return jresult;
32895 }
32896
32897
32898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32899   void * jresult ;
32900   Dali::Actor *arg1 ;
32901   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32902
32903   arg1 = (Dali::Actor *)jarg1;
32904   {
32905     try {
32906       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32907     } catch (std::out_of_range& e) {
32908       {
32909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32910       };
32911     } catch (std::exception& e) {
32912       {
32913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32914       };
32915     } catch (Dali::DaliException e) {
32916       {
32917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32918       };
32919     } catch (...) {
32920       {
32921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32922       };
32923     }
32924   }
32925
32926   jresult = (void *)result;
32927   return jresult;
32928 }
32929
32930
32931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32932   int jresult ;
32933   int result;
32934
32935   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32936   jresult = (int)result;
32937   return jresult;
32938 }
32939
32940
32941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32942   int jresult ;
32943   int result;
32944
32945   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32946   jresult = (int)result;
32947   return jresult;
32948 }
32949
32950
32951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32952   int jresult ;
32953   int result;
32954
32955   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32956   jresult = (int)result;
32957   return jresult;
32958 }
32959
32960
32961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32962   int jresult ;
32963   int result;
32964
32965   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32966   jresult = (int)result;
32967   return jresult;
32968 }
32969
32970
32971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32972   int jresult ;
32973   int result;
32974
32975   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32976   jresult = (int)result;
32977   return jresult;
32978 }
32979
32980
32981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32982   int jresult ;
32983   int result;
32984
32985   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32986   jresult = (int)result;
32987   return jresult;
32988 }
32989
32990
32991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32992   int jresult ;
32993   int result;
32994
32995   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32996   jresult = (int)result;
32997   return jresult;
32998 }
32999
33000
33001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
33002   int jresult ;
33003   int result;
33004
33005   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
33006   jresult = (int)result;
33007   return jresult;
33008 }
33009
33010
33011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
33012   int jresult ;
33013   int result;
33014
33015   result = (int)Dali::Actor::Property::SIZE;
33016   jresult = (int)result;
33017   return jresult;
33018 }
33019
33020
33021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
33022   int jresult ;
33023   int result;
33024
33025   result = (int)Dali::Actor::Property::SIZE_WIDTH;
33026   jresult = (int)result;
33027   return jresult;
33028 }
33029
33030
33031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
33032   int jresult ;
33033   int result;
33034
33035   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
33036   jresult = (int)result;
33037   return jresult;
33038 }
33039
33040
33041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
33042   int jresult ;
33043   int result;
33044
33045   result = (int)Dali::Actor::Property::SIZE_DEPTH;
33046   jresult = (int)result;
33047   return jresult;
33048 }
33049
33050
33051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
33052   int jresult ;
33053   int result;
33054
33055   result = (int)Dali::Actor::Property::POSITION;
33056   jresult = (int)result;
33057   return jresult;
33058 }
33059
33060
33061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
33062   int jresult ;
33063   int result;
33064
33065   result = (int)Dali::Actor::Property::POSITION_X;
33066   jresult = (int)result;
33067   return jresult;
33068 }
33069
33070
33071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33072   int jresult ;
33073   int result;
33074
33075   result = (int)Dali::Actor::Property::POSITION_Y;
33076   jresult = (int)result;
33077   return jresult;
33078 }
33079
33080
33081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33082   int jresult ;
33083   int result;
33084
33085   result = (int)Dali::Actor::Property::POSITION_Z;
33086   jresult = (int)result;
33087   return jresult;
33088 }
33089
33090
33091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33092   int jresult ;
33093   int result;
33094
33095   result = (int)Dali::Actor::Property::WORLD_POSITION;
33096   jresult = (int)result;
33097   return jresult;
33098 }
33099
33100
33101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33102   int jresult ;
33103   int result;
33104
33105   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33106   jresult = (int)result;
33107   return jresult;
33108 }
33109
33110
33111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33112   int jresult ;
33113   int result;
33114
33115   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33116   jresult = (int)result;
33117   return jresult;
33118 }
33119
33120
33121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33122   int jresult ;
33123   int result;
33124
33125   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33126   jresult = (int)result;
33127   return jresult;
33128 }
33129
33130
33131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33132   int jresult ;
33133   int result;
33134
33135   result = (int)Dali::Actor::Property::ORIENTATION;
33136   jresult = (int)result;
33137   return jresult;
33138 }
33139
33140
33141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33142   int jresult ;
33143   int result;
33144
33145   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33146   jresult = (int)result;
33147   return jresult;
33148 }
33149
33150
33151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33152   int jresult ;
33153   int result;
33154
33155   result = (int)Dali::Actor::Property::SCALE;
33156   jresult = (int)result;
33157   return jresult;
33158 }
33159
33160
33161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33162   int jresult ;
33163   int result;
33164
33165   result = (int)Dali::Actor::Property::SCALE_X;
33166   jresult = (int)result;
33167   return jresult;
33168 }
33169
33170
33171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33172   int jresult ;
33173   int result;
33174
33175   result = (int)Dali::Actor::Property::SCALE_Y;
33176   jresult = (int)result;
33177   return jresult;
33178 }
33179
33180
33181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33182   int jresult ;
33183   int result;
33184
33185   result = (int)Dali::Actor::Property::SCALE_Z;
33186   jresult = (int)result;
33187   return jresult;
33188 }
33189
33190
33191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33192   int jresult ;
33193   int result;
33194
33195   result = (int)Dali::Actor::Property::WORLD_SCALE;
33196   jresult = (int)result;
33197   return jresult;
33198 }
33199
33200
33201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33202   int jresult ;
33203   int result;
33204
33205   result = (int)Dali::Actor::Property::VISIBLE;
33206   jresult = (int)result;
33207   return jresult;
33208 }
33209
33210
33211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33212   int jresult ;
33213   int result;
33214
33215   result = (int)Dali::Actor::Property::COLOR;
33216   jresult = (int)result;
33217   return jresult;
33218 }
33219
33220
33221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33222   int jresult ;
33223   int result;
33224
33225   result = (int)Dali::Actor::Property::COLOR_RED;
33226   jresult = (int)result;
33227   return jresult;
33228 }
33229
33230
33231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33232   int jresult ;
33233   int result;
33234
33235   result = (int)Dali::Actor::Property::COLOR_GREEN;
33236   jresult = (int)result;
33237   return jresult;
33238 }
33239
33240
33241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33242   int jresult ;
33243   int result;
33244
33245   result = (int)Dali::Actor::Property::COLOR_BLUE;
33246   jresult = (int)result;
33247   return jresult;
33248 }
33249
33250
33251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33252   int jresult ;
33253   int result;
33254
33255   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33256   jresult = (int)result;
33257   return jresult;
33258 }
33259
33260
33261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33262   int jresult ;
33263   int result;
33264
33265   result = (int)Dali::Actor::Property::WORLD_COLOR;
33266   jresult = (int)result;
33267   return jresult;
33268 }
33269
33270
33271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33272   int jresult ;
33273   int result;
33274
33275   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33276   jresult = (int)result;
33277   return jresult;
33278 }
33279
33280
33281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33282   int jresult ;
33283   int result;
33284
33285   result = (int)Dali::Actor::Property::NAME;
33286   jresult = (int)result;
33287   return jresult;
33288 }
33289
33290
33291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33292   int jresult ;
33293   int result;
33294
33295   result = (int)Dali::Actor::Property::SENSITIVE;
33296   jresult = (int)result;
33297   return jresult;
33298 }
33299
33300
33301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33302   int jresult ;
33303   int result;
33304
33305   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33306   jresult = (int)result;
33307   return jresult;
33308 }
33309
33310
33311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33312   int jresult ;
33313   int result;
33314
33315   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33316   jresult = (int)result;
33317   return jresult;
33318 }
33319
33320
33321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33322   int jresult ;
33323   int result;
33324
33325   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33326   jresult = (int)result;
33327   return jresult;
33328 }
33329
33330
33331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33332   int jresult ;
33333   int result;
33334
33335   result = (int)Dali::Actor::Property::COLOR_MODE;
33336   jresult = (int)result;
33337   return jresult;
33338 }
33339
33340
33341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33342   int jresult ;
33343   int result;
33344
33345   result = (int)Dali::Actor::Property::DRAW_MODE;
33346   jresult = (int)result;
33347   return jresult;
33348 }
33349
33350
33351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33352   int jresult ;
33353   int result;
33354
33355   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33356   jresult = (int)result;
33357   return jresult;
33358 }
33359
33360
33361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33362   int jresult ;
33363   int result;
33364
33365   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33366   jresult = (int)result;
33367   return jresult;
33368 }
33369
33370
33371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33372   int jresult ;
33373   int result;
33374
33375   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33376   jresult = (int)result;
33377   return jresult;
33378 }
33379
33380
33381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33382   int jresult ;
33383   int result;
33384
33385   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33386   jresult = (int)result;
33387   return jresult;
33388 }
33389
33390
33391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33392   int jresult ;
33393   int result;
33394
33395   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33396   jresult = (int)result;
33397   return jresult;
33398 }
33399
33400
33401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33402   int jresult ;
33403   int result;
33404
33405   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33406   jresult = (int)result;
33407   return jresult;
33408 }
33409
33410
33411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33412   int jresult ;
33413   int result;
33414
33415   result = (int)Dali::Actor::Property::PADDING;
33416   jresult = (int)result;
33417   return jresult;
33418 }
33419
33420
33421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33422   int jresult ;
33423   int result;
33424
33425   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33426   jresult = (int)result;
33427   return jresult;
33428 }
33429
33430
33431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33432   int jresult ;
33433   int result;
33434
33435   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33436   jresult = (int)result;
33437   return jresult;
33438 }
33439
33440
33441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33442   int jresult ;
33443   int result;
33444
33445   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33446   jresult = (int)result;
33447   return jresult;
33448 }
33449
33450
33451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33452   int jresult ;
33453   int result;
33454
33455   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33456   jresult = (int)result;
33457   return jresult;
33458 }
33459
33460
33461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33462   void * jresult ;
33463   Dali::Actor::Property *result = 0 ;
33464
33465   {
33466     try {
33467       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33468     } catch (std::out_of_range& e) {
33469       {
33470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33471       };
33472     } catch (std::exception& e) {
33473       {
33474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33475       };
33476     } catch (Dali::DaliException e) {
33477       {
33478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33479       };
33480     } catch (...) {
33481       {
33482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33483       };
33484     }
33485   }
33486
33487   jresult = (void *)result;
33488   return jresult;
33489 }
33490
33491
33492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33493   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33494
33495   arg1 = (Dali::Actor::Property *)jarg1;
33496   {
33497     try {
33498       delete arg1;
33499     } catch (std::out_of_range& e) {
33500       {
33501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33502       };
33503     } catch (std::exception& e) {
33504       {
33505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33506       };
33507     } catch (Dali::DaliException e) {
33508       {
33509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33510       };
33511     } catch (...) {
33512       {
33513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33514       };
33515     }
33516   }
33517
33518 }
33519
33520
33521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33522   void * jresult ;
33523   Dali::Actor *result = 0 ;
33524
33525   {
33526     try {
33527       result = (Dali::Actor *)new Dali::Actor();
33528     } catch (std::out_of_range& e) {
33529       {
33530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33531       };
33532     } catch (std::exception& e) {
33533       {
33534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33535       };
33536     } catch (Dali::DaliException e) {
33537       {
33538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33539       };
33540     } catch (...) {
33541       {
33542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33543       };
33544     }
33545   }
33546
33547   jresult = (void *)result;
33548   return jresult;
33549 }
33550
33551
33552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33553   void * jresult ;
33554   Dali::Actor result;
33555
33556   {
33557     try {
33558       result = Dali::Actor::New();
33559     } catch (std::out_of_range& e) {
33560       {
33561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33562       };
33563     } catch (std::exception& e) {
33564       {
33565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33566       };
33567     } catch (Dali::DaliException e) {
33568       {
33569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33570       };
33571     } catch (...) {
33572       {
33573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33574       };
33575     }
33576   }
33577
33578   jresult = new Dali::Actor((const Dali::Actor &)result);
33579   return jresult;
33580 }
33581
33582
33583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33584   void * jresult ;
33585   Dali::BaseHandle arg1 ;
33586   Dali::BaseHandle *argp1 ;
33587   Dali::Actor result;
33588
33589   argp1 = (Dali::BaseHandle *)jarg1;
33590   if (!argp1) {
33591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33592     return 0;
33593   }
33594   arg1 = *argp1;
33595   {
33596     try {
33597       result = Dali::Actor::DownCast(arg1);
33598     } catch (std::out_of_range& e) {
33599       {
33600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33601       };
33602     } catch (std::exception& e) {
33603       {
33604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33605       };
33606     } catch (Dali::DaliException e) {
33607       {
33608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33609       };
33610     } catch (...) {
33611       {
33612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33613       };
33614     }
33615   }
33616
33617   jresult = new Dali::Actor((const Dali::Actor &)result);
33618   return jresult;
33619 }
33620
33621
33622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33623   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33624
33625   arg1 = (Dali::Actor *)jarg1;
33626   {
33627     try {
33628       delete arg1;
33629     } catch (std::out_of_range& e) {
33630       {
33631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33632       };
33633     } catch (std::exception& e) {
33634       {
33635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33636       };
33637     } catch (Dali::DaliException e) {
33638       {
33639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33640       };
33641     } catch (...) {
33642       {
33643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33644       };
33645     }
33646   }
33647
33648 }
33649
33650
33651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33652   void * jresult ;
33653   Dali::Actor *arg1 = 0 ;
33654   Dali::Actor *result = 0 ;
33655
33656   arg1 = (Dali::Actor *)jarg1;
33657   if (!arg1) {
33658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33659     return 0;
33660   }
33661   {
33662     try {
33663       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33664     } catch (std::out_of_range& e) {
33665       {
33666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33667       };
33668     } catch (std::exception& e) {
33669       {
33670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33671       };
33672     } catch (Dali::DaliException e) {
33673       {
33674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33675       };
33676     } catch (...) {
33677       {
33678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33679       };
33680     }
33681   }
33682
33683   jresult = (void *)result;
33684   return jresult;
33685 }
33686
33687
33688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33689   void * jresult ;
33690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33691   Dali::Actor *arg2 = 0 ;
33692   Dali::Actor *result = 0 ;
33693
33694   arg1 = (Dali::Actor *)jarg1;
33695   arg2 = (Dali::Actor *)jarg2;
33696   if (!arg2) {
33697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33698     return 0;
33699   }
33700   {
33701     try {
33702       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33703     } catch (std::out_of_range& e) {
33704       {
33705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33706       };
33707     } catch (std::exception& e) {
33708       {
33709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33710       };
33711     } catch (Dali::DaliException e) {
33712       {
33713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33714       };
33715     } catch (...) {
33716       {
33717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33718       };
33719     }
33720   }
33721
33722   jresult = (void *)result;
33723   return jresult;
33724 }
33725
33726
33727 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33728   char * jresult ;
33729   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33730   std::string *result = 0 ;
33731
33732   arg1 = (Dali::Actor *)jarg1;
33733   {
33734     try {
33735       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33736     } catch (std::out_of_range& e) {
33737       {
33738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33739       };
33740     } catch (std::exception& e) {
33741       {
33742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33743       };
33744     } catch (Dali::DaliException e) {
33745       {
33746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33747       };
33748     } catch (...) {
33749       {
33750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33751       };
33752     }
33753   }
33754
33755   jresult = SWIG_csharp_string_callback(result->c_str());
33756   return jresult;
33757 }
33758
33759
33760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33761   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33762   std::string *arg2 = 0 ;
33763
33764   arg1 = (Dali::Actor *)jarg1;
33765   if (!jarg2) {
33766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33767     return ;
33768   }
33769   std::string arg2_str(jarg2);
33770   arg2 = &arg2_str;
33771   {
33772     try {
33773       (arg1)->SetName((std::string const &)*arg2);
33774     } catch (std::out_of_range& e) {
33775       {
33776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33777       };
33778     } catch (std::exception& e) {
33779       {
33780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33781       };
33782     } catch (Dali::DaliException e) {
33783       {
33784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33785       };
33786     } catch (...) {
33787       {
33788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33789       };
33790     }
33791   }
33792
33793
33794   //argout typemap for const std::string&
33795
33796 }
33797
33798
33799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33800   unsigned int jresult ;
33801   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33802   unsigned int result;
33803
33804   arg1 = (Dali::Actor *)jarg1;
33805
33806   if(!arg1) {
33807     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33808     return -1;
33809   }
33810
33811   {
33812     try {
33813       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33814     } catch (std::out_of_range& e) {
33815       {
33816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33817       };
33818     } catch (std::exception& e) {
33819       {
33820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33821       };
33822     } catch (Dali::DaliException e) {
33823       {
33824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33825       };
33826     } catch (...) {
33827       {
33828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33829       };
33830     }
33831   }
33832
33833   jresult = result;
33834   return jresult;
33835 }
33836
33837
33838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33839   unsigned int jresult ;
33840   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33841   bool result;
33842
33843   arg1 = (Dali::Actor *)jarg1;
33844   {
33845     try {
33846       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33847     } catch (std::out_of_range& e) {
33848       {
33849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33850       };
33851     } catch (std::exception& e) {
33852       {
33853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33854       };
33855     } catch (Dali::DaliException e) {
33856       {
33857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33858       };
33859     } catch (...) {
33860       {
33861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33862       };
33863     }
33864   }
33865
33866   jresult = result;
33867   return jresult;
33868 }
33869
33870
33871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33872   unsigned int jresult ;
33873   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33874   bool result;
33875
33876   arg1 = (Dali::Actor *)jarg1;
33877   {
33878     try {
33879       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33880     } catch (std::out_of_range& e) {
33881       {
33882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33883       };
33884     } catch (std::exception& e) {
33885       {
33886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33887       };
33888     } catch (Dali::DaliException e) {
33889       {
33890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33891       };
33892     } catch (...) {
33893       {
33894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33895       };
33896     }
33897   }
33898
33899   jresult = result;
33900   return jresult;
33901 }
33902
33903
33904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33905   unsigned int jresult ;
33906   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33907   bool result;
33908
33909   arg1 = (Dali::Actor *)jarg1;
33910   {
33911     try {
33912       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33913     } catch (std::out_of_range& e) {
33914       {
33915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33916       };
33917     } catch (std::exception& e) {
33918       {
33919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33920       };
33921     } catch (Dali::DaliException e) {
33922       {
33923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33924       };
33925     } catch (...) {
33926       {
33927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33928       };
33929     }
33930   }
33931
33932   jresult = result;
33933   return jresult;
33934 }
33935
33936
33937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33938   void * jresult ;
33939   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33940   Dali::Layer result;
33941
33942   arg1 = (Dali::Actor *)jarg1;
33943   {
33944     try {
33945       result = (arg1)->GetLayer();
33946     } catch (std::out_of_range& e) {
33947       {
33948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33949       };
33950     } catch (std::exception& e) {
33951       {
33952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33953       };
33954     } catch (Dali::DaliException e) {
33955       {
33956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33957       };
33958     } catch (...) {
33959       {
33960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33961       };
33962     }
33963   }
33964
33965   jresult = new Dali::Layer((const Dali::Layer &)result);
33966   return jresult;
33967 }
33968
33969
33970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33971   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33972   Dali::Actor arg2 ;
33973   Dali::Actor *argp2 ;
33974
33975   arg1 = (Dali::Actor *)jarg1;
33976   argp2 = (Dali::Actor *)jarg2;
33977   if (!argp2) {
33978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33979     return ;
33980   }
33981   arg2 = *argp2;
33982   {
33983     try {
33984       (arg1)->Add(arg2);
33985     } catch (std::out_of_range& e) {
33986       {
33987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33988       };
33989     } catch (std::exception& e) {
33990       {
33991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33992       };
33993     } catch (Dali::DaliException e) {
33994       {
33995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33996       };
33997     } catch (...) {
33998       {
33999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34000       };
34001     }
34002   }
34003
34004 }
34005
34006
34007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
34008   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34009   Dali::Actor arg2 ;
34010   Dali::Actor *argp2 ;
34011
34012   arg1 = (Dali::Actor *)jarg1;
34013   argp2 = (Dali::Actor *)jarg2;
34014   if (!argp2) {
34015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34016     return ;
34017   }
34018   arg2 = *argp2;
34019   {
34020     try {
34021       (arg1)->Remove(arg2);
34022     } catch (std::out_of_range& e) {
34023       {
34024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34025       };
34026     } catch (std::exception& e) {
34027       {
34028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34029       };
34030     } catch (Dali::DaliException e) {
34031       {
34032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34033       };
34034     } catch (...) {
34035       {
34036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34037       };
34038     }
34039   }
34040
34041 }
34042
34043
34044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34045   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34046
34047   arg1 = (Dali::Actor *)jarg1;
34048   {
34049     try {
34050       (arg1)->Unparent();
34051     } catch (std::out_of_range& e) {
34052       {
34053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34054       };
34055     } catch (std::exception& e) {
34056       {
34057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34058       };
34059     } catch (Dali::DaliException e) {
34060       {
34061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34062       };
34063     } catch (...) {
34064       {
34065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34066       };
34067     }
34068   }
34069
34070 }
34071
34072
34073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34074   unsigned int jresult ;
34075   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34076   unsigned int result;
34077
34078   arg1 = (Dali::Actor *)jarg1;
34079   {
34080     try {
34081       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34082     } catch (std::out_of_range& e) {
34083       {
34084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34085       };
34086     } catch (std::exception& e) {
34087       {
34088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34089       };
34090     } catch (Dali::DaliException e) {
34091       {
34092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34093       };
34094     } catch (...) {
34095       {
34096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34097       };
34098     }
34099   }
34100
34101   jresult = result;
34102   return jresult;
34103 }
34104
34105
34106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34107   void * jresult ;
34108   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34109   unsigned int arg2 ;
34110   Dali::Actor result;
34111
34112   arg1 = (Dali::Actor *)jarg1;
34113   arg2 = (unsigned int)jarg2;
34114   {
34115     try {
34116       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34117     } catch (std::out_of_range& e) {
34118       {
34119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34120       };
34121     } catch (std::exception& e) {
34122       {
34123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34124       };
34125     } catch (Dali::DaliException e) {
34126       {
34127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34128       };
34129     } catch (...) {
34130       {
34131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34132       };
34133     }
34134   }
34135
34136   jresult = new Dali::Actor((const Dali::Actor &)result);
34137   return jresult;
34138 }
34139
34140
34141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34142   void * jresult ;
34143   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34144   std::string *arg2 = 0 ;
34145   Dali::Actor result;
34146
34147   arg1 = (Dali::Actor *)jarg1;
34148   if (!jarg2) {
34149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34150     return 0;
34151   }
34152   std::string arg2_str(jarg2);
34153   arg2 = &arg2_str;
34154   {
34155     try {
34156       result = (arg1)->FindChildByName((std::string const &)*arg2);
34157     } catch (std::out_of_range& e) {
34158       {
34159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34160       };
34161     } catch (std::exception& e) {
34162       {
34163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34164       };
34165     } catch (Dali::DaliException e) {
34166       {
34167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34168       };
34169     } catch (...) {
34170       {
34171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34172       };
34173     }
34174   }
34175
34176   jresult = new Dali::Actor((const Dali::Actor &)result);
34177
34178   //argout typemap for const std::string&
34179
34180   return jresult;
34181 }
34182
34183
34184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34185   void * jresult ;
34186   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34187   unsigned int arg2 ;
34188   Dali::Actor result;
34189
34190   arg1 = (Dali::Actor *)jarg1;
34191   arg2 = (unsigned int)jarg2;
34192   {
34193     try {
34194       result = (arg1)->FindChildById(arg2);
34195     } catch (std::out_of_range& e) {
34196       {
34197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34198       };
34199     } catch (std::exception& e) {
34200       {
34201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34202       };
34203     } catch (Dali::DaliException e) {
34204       {
34205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34206       };
34207     } catch (...) {
34208       {
34209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34210       };
34211     }
34212   }
34213
34214   jresult = new Dali::Actor((const Dali::Actor &)result);
34215   return jresult;
34216 }
34217
34218
34219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34220   void * jresult ;
34221   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34222   Dali::Actor result;
34223
34224   arg1 = (Dali::Actor *)jarg1;
34225   {
34226     try {
34227       result = ((Dali::Actor const *)arg1)->GetParent();
34228     } catch (std::out_of_range& e) {
34229       {
34230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34231       };
34232     } catch (std::exception& e) {
34233       {
34234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34235       };
34236     } catch (Dali::DaliException e) {
34237       {
34238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34239       };
34240     } catch (...) {
34241       {
34242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34243       };
34244     }
34245   }
34246
34247   jresult = new Dali::Actor((const Dali::Actor &)result);
34248   return jresult;
34249 }
34250
34251
34252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34253   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34254   Dali::Vector3 *arg2 = 0 ;
34255
34256   arg1 = (Dali::Actor *)jarg1;
34257   arg2 = (Dali::Vector3 *)jarg2;
34258   if (!arg2) {
34259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34260     return ;
34261   }
34262   {
34263     try {
34264       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34265     } catch (std::out_of_range& e) {
34266       {
34267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34268       };
34269     } catch (std::exception& e) {
34270       {
34271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34272       };
34273     } catch (Dali::DaliException e) {
34274       {
34275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34276       };
34277     } catch (...) {
34278       {
34279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34280       };
34281     }
34282   }
34283
34284 }
34285
34286
34287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34288   void * jresult ;
34289   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34290   Dali::Vector3 result;
34291
34292   arg1 = (Dali::Actor *)jarg1;
34293   {
34294     try {
34295       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34296     } catch (std::out_of_range& e) {
34297       {
34298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34299       };
34300     } catch (std::exception& e) {
34301       {
34302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34303       };
34304     } catch (Dali::DaliException e) {
34305       {
34306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34307       };
34308     } catch (...) {
34309       {
34310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34311       };
34312     }
34313   }
34314
34315   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34316   return jresult;
34317 }
34318
34319
34320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34321   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34322   Dali::Vector3 *arg2 = 0 ;
34323
34324   arg1 = (Dali::Actor *)jarg1;
34325   arg2 = (Dali::Vector3 *)jarg2;
34326   if (!arg2) {
34327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34328     return ;
34329   }
34330   {
34331     try {
34332       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34333     } catch (std::out_of_range& e) {
34334       {
34335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34336       };
34337     } catch (std::exception& e) {
34338       {
34339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34340       };
34341     } catch (Dali::DaliException e) {
34342       {
34343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34344       };
34345     } catch (...) {
34346       {
34347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34348       };
34349     }
34350   }
34351
34352 }
34353
34354
34355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34356   void * jresult ;
34357   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34358   Dali::Vector3 result;
34359
34360   arg1 = (Dali::Actor *)jarg1;
34361   {
34362     try {
34363       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34364     } catch (std::out_of_range& e) {
34365       {
34366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34367       };
34368     } catch (std::exception& e) {
34369       {
34370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34371       };
34372     } catch (Dali::DaliException e) {
34373       {
34374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34375       };
34376     } catch (...) {
34377       {
34378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34379       };
34380     }
34381   }
34382
34383   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34384   return jresult;
34385 }
34386
34387
34388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34389   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34390   float arg2 ;
34391   float arg3 ;
34392
34393   arg1 = (Dali::Actor *)jarg1;
34394   arg2 = (float)jarg2;
34395   arg3 = (float)jarg3;
34396   {
34397     try {
34398       (arg1)->SetSize(arg2,arg3);
34399     } catch (std::out_of_range& e) {
34400       {
34401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34402       };
34403     } catch (std::exception& e) {
34404       {
34405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34406       };
34407     } catch (Dali::DaliException e) {
34408       {
34409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34410       };
34411     } catch (...) {
34412       {
34413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34414       };
34415     }
34416   }
34417
34418 }
34419
34420
34421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34422   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34423   float arg2 ;
34424   float arg3 ;
34425   float arg4 ;
34426
34427   arg1 = (Dali::Actor *)jarg1;
34428   arg2 = (float)jarg2;
34429   arg3 = (float)jarg3;
34430   arg4 = (float)jarg4;
34431   {
34432     try {
34433       (arg1)->SetSize(arg2,arg3,arg4);
34434     } catch (std::out_of_range& e) {
34435       {
34436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34437       };
34438     } catch (std::exception& e) {
34439       {
34440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34441       };
34442     } catch (Dali::DaliException e) {
34443       {
34444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34445       };
34446     } catch (...) {
34447       {
34448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34449       };
34450     }
34451   }
34452
34453 }
34454
34455
34456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34457   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34458   Dali::Vector2 *arg2 = 0 ;
34459
34460   arg1 = (Dali::Actor *)jarg1;
34461   arg2 = (Dali::Vector2 *)jarg2;
34462   if (!arg2) {
34463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34464     return ;
34465   }
34466   {
34467     try {
34468       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34469     } catch (std::out_of_range& e) {
34470       {
34471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34472       };
34473     } catch (std::exception& e) {
34474       {
34475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34476       };
34477     } catch (Dali::DaliException e) {
34478       {
34479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34480       };
34481     } catch (...) {
34482       {
34483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34484       };
34485     }
34486   }
34487
34488 }
34489
34490
34491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34492   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34493   Dali::Vector3 *arg2 = 0 ;
34494
34495   arg1 = (Dali::Actor *)jarg1;
34496   arg2 = (Dali::Vector3 *)jarg2;
34497   if (!arg2) {
34498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34499     return ;
34500   }
34501   {
34502     try {
34503       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34504     } catch (std::out_of_range& e) {
34505       {
34506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34507       };
34508     } catch (std::exception& e) {
34509       {
34510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34511       };
34512     } catch (Dali::DaliException e) {
34513       {
34514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34515       };
34516     } catch (...) {
34517       {
34518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34519       };
34520     }
34521   }
34522
34523 }
34524
34525
34526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34527   void * jresult ;
34528   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34529   Dali::Vector3 result;
34530
34531   arg1 = (Dali::Actor *)jarg1;
34532   {
34533     try {
34534       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34535     } catch (std::out_of_range& e) {
34536       {
34537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34538       };
34539     } catch (std::exception& e) {
34540       {
34541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34542       };
34543     } catch (Dali::DaliException e) {
34544       {
34545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34546       };
34547     } catch (...) {
34548       {
34549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34550       };
34551     }
34552   }
34553
34554   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34555   return jresult;
34556 }
34557
34558
34559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34560   void * jresult ;
34561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34562   Dali::Vector3 result;
34563
34564   arg1 = (Dali::Actor *)jarg1;
34565   {
34566     try {
34567       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34568     } catch (std::out_of_range& e) {
34569       {
34570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34571       };
34572     } catch (std::exception& e) {
34573       {
34574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34575       };
34576     } catch (Dali::DaliException e) {
34577       {
34578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34579       };
34580     } catch (...) {
34581       {
34582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34583       };
34584     }
34585   }
34586
34587   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34588   return jresult;
34589 }
34590
34591
34592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34593   void * jresult ;
34594   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34595   Dali::Vector3 result;
34596
34597   arg1 = (Dali::Actor *)jarg1;
34598   {
34599     try {
34600       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34601     } catch (std::out_of_range& e) {
34602       {
34603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34604       };
34605     } catch (std::exception& e) {
34606       {
34607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34608       };
34609     } catch (Dali::DaliException e) {
34610       {
34611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34612       };
34613     } catch (...) {
34614       {
34615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34616       };
34617     }
34618   }
34619
34620   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34621   return jresult;
34622 }
34623
34624
34625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34626   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34627   float arg2 ;
34628   float arg3 ;
34629
34630   arg1 = (Dali::Actor *)jarg1;
34631   arg2 = (float)jarg2;
34632   arg3 = (float)jarg3;
34633   {
34634     try {
34635       (arg1)->SetPosition(arg2,arg3);
34636     } catch (std::out_of_range& e) {
34637       {
34638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34639       };
34640     } catch (std::exception& e) {
34641       {
34642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34643       };
34644     } catch (Dali::DaliException e) {
34645       {
34646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34647       };
34648     } catch (...) {
34649       {
34650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34651       };
34652     }
34653   }
34654
34655 }
34656
34657
34658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34659   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34660   float arg2 ;
34661   float arg3 ;
34662   float arg4 ;
34663
34664   arg1 = (Dali::Actor *)jarg1;
34665   arg2 = (float)jarg2;
34666   arg3 = (float)jarg3;
34667   arg4 = (float)jarg4;
34668   {
34669     try {
34670       (arg1)->SetPosition(arg2,arg3,arg4);
34671     } catch (std::out_of_range& e) {
34672       {
34673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34674       };
34675     } catch (std::exception& e) {
34676       {
34677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34678       };
34679     } catch (Dali::DaliException e) {
34680       {
34681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34682       };
34683     } catch (...) {
34684       {
34685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34686       };
34687     }
34688   }
34689
34690 }
34691
34692
34693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34694   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34695   Dali::Vector3 *arg2 = 0 ;
34696
34697   arg1 = (Dali::Actor *)jarg1;
34698   arg2 = (Dali::Vector3 *)jarg2;
34699   if (!arg2) {
34700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34701     return ;
34702   }
34703   {
34704     try {
34705       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34706     } catch (std::out_of_range& e) {
34707       {
34708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34709       };
34710     } catch (std::exception& e) {
34711       {
34712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34713       };
34714     } catch (Dali::DaliException e) {
34715       {
34716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34717       };
34718     } catch (...) {
34719       {
34720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34721       };
34722     }
34723   }
34724
34725 }
34726
34727
34728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34729   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34730   float arg2 ;
34731
34732   arg1 = (Dali::Actor *)jarg1;
34733   arg2 = (float)jarg2;
34734   {
34735     try {
34736       (arg1)->SetX(arg2);
34737     } catch (std::out_of_range& e) {
34738       {
34739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34740       };
34741     } catch (std::exception& e) {
34742       {
34743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34744       };
34745     } catch (Dali::DaliException e) {
34746       {
34747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34748       };
34749     } catch (...) {
34750       {
34751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34752       };
34753     }
34754   }
34755
34756 }
34757
34758
34759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34761   float arg2 ;
34762
34763   arg1 = (Dali::Actor *)jarg1;
34764   arg2 = (float)jarg2;
34765   {
34766     try {
34767       (arg1)->SetY(arg2);
34768     } catch (std::out_of_range& e) {
34769       {
34770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34771       };
34772     } catch (std::exception& e) {
34773       {
34774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34775       };
34776     } catch (Dali::DaliException e) {
34777       {
34778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34779       };
34780     } catch (...) {
34781       {
34782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34783       };
34784     }
34785   }
34786
34787 }
34788
34789
34790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34791   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34792   float arg2 ;
34793
34794   arg1 = (Dali::Actor *)jarg1;
34795   arg2 = (float)jarg2;
34796   {
34797     try {
34798       (arg1)->SetZ(arg2);
34799     } catch (std::out_of_range& e) {
34800       {
34801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34802       };
34803     } catch (std::exception& e) {
34804       {
34805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34806       };
34807     } catch (Dali::DaliException e) {
34808       {
34809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34810       };
34811     } catch (...) {
34812       {
34813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34814       };
34815     }
34816   }
34817
34818 }
34819
34820
34821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34822   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34823   Dali::Vector3 *arg2 = 0 ;
34824
34825   arg1 = (Dali::Actor *)jarg1;
34826   arg2 = (Dali::Vector3 *)jarg2;
34827   if (!arg2) {
34828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34829     return ;
34830   }
34831   {
34832     try {
34833       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34834     } catch (std::out_of_range& e) {
34835       {
34836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34837       };
34838     } catch (std::exception& e) {
34839       {
34840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34841       };
34842     } catch (Dali::DaliException e) {
34843       {
34844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34845       };
34846     } catch (...) {
34847       {
34848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34849       };
34850     }
34851   }
34852
34853 }
34854
34855
34856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34857   void * jresult ;
34858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34859   Dali::Vector3 result;
34860
34861   arg1 = (Dali::Actor *)jarg1;
34862   {
34863     try {
34864       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34865     } catch (std::out_of_range& e) {
34866       {
34867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34868       };
34869     } catch (std::exception& e) {
34870       {
34871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34872       };
34873     } catch (Dali::DaliException e) {
34874       {
34875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34876       };
34877     } catch (...) {
34878       {
34879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34880       };
34881     }
34882   }
34883
34884   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34885   return jresult;
34886 }
34887
34888
34889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34890   void * jresult ;
34891   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34892   Dali::Vector3 result;
34893
34894   arg1 = (Dali::Actor *)jarg1;
34895   {
34896     try {
34897       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34898     } catch (std::out_of_range& e) {
34899       {
34900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34901       };
34902     } catch (std::exception& e) {
34903       {
34904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34905       };
34906     } catch (Dali::DaliException e) {
34907       {
34908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34909       };
34910     } catch (...) {
34911       {
34912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34913       };
34914     }
34915   }
34916
34917   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34918   return jresult;
34919 }
34920
34921
34922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34923   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34924   bool arg2 ;
34925
34926   arg1 = (Dali::Actor *)jarg1;
34927   arg2 = jarg2 ? true : false;
34928   {
34929     try {
34930       (arg1)->SetInheritPosition(arg2);
34931     } catch (std::out_of_range& e) {
34932       {
34933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34934       };
34935     } catch (std::exception& e) {
34936       {
34937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34938       };
34939     } catch (Dali::DaliException e) {
34940       {
34941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34942       };
34943     } catch (...) {
34944       {
34945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34946       };
34947     }
34948   }
34949
34950 }
34951
34952
34953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34954   unsigned int jresult ;
34955   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34956   bool result;
34957
34958   arg1 = (Dali::Actor *)jarg1;
34959   {
34960     try {
34961       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34962     } catch (std::out_of_range& e) {
34963       {
34964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34965       };
34966     } catch (std::exception& e) {
34967       {
34968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34969       };
34970     } catch (Dali::DaliException e) {
34971       {
34972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34973       };
34974     } catch (...) {
34975       {
34976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34977       };
34978     }
34979   }
34980
34981   jresult = result;
34982   return jresult;
34983 }
34984
34985
34986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34987   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34988   Dali::Degree *arg2 = 0 ;
34989   Dali::Vector3 *arg3 = 0 ;
34990
34991   arg1 = (Dali::Actor *)jarg1;
34992   arg2 = (Dali::Degree *)jarg2;
34993   if (!arg2) {
34994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34995     return ;
34996   }
34997   arg3 = (Dali::Vector3 *)jarg3;
34998   if (!arg3) {
34999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35000     return ;
35001   }
35002   {
35003     try {
35004       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35005     } catch (std::out_of_range& e) {
35006       {
35007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35008       };
35009     } catch (std::exception& e) {
35010       {
35011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35012       };
35013     } catch (Dali::DaliException e) {
35014       {
35015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35016       };
35017     } catch (...) {
35018       {
35019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35020       };
35021     }
35022   }
35023
35024 }
35025
35026
35027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35029   Dali::Radian *arg2 = 0 ;
35030   Dali::Vector3 *arg3 = 0 ;
35031
35032   arg1 = (Dali::Actor *)jarg1;
35033   arg2 = (Dali::Radian *)jarg2;
35034   if (!arg2) {
35035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35036     return ;
35037   }
35038   arg3 = (Dali::Vector3 *)jarg3;
35039   if (!arg3) {
35040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35041     return ;
35042   }
35043   {
35044     try {
35045       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35046     } catch (std::out_of_range& e) {
35047       {
35048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35049       };
35050     } catch (std::exception& e) {
35051       {
35052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35053       };
35054     } catch (Dali::DaliException e) {
35055       {
35056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35057       };
35058     } catch (...) {
35059       {
35060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35061       };
35062     }
35063   }
35064
35065 }
35066
35067
35068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35069   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35070   Dali::Quaternion *arg2 = 0 ;
35071
35072   arg1 = (Dali::Actor *)jarg1;
35073   arg2 = (Dali::Quaternion *)jarg2;
35074   if (!arg2) {
35075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35076     return ;
35077   }
35078   {
35079     try {
35080       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35081     } catch (std::out_of_range& e) {
35082       {
35083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35084       };
35085     } catch (std::exception& e) {
35086       {
35087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35088       };
35089     } catch (Dali::DaliException e) {
35090       {
35091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35092       };
35093     } catch (...) {
35094       {
35095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35096       };
35097     }
35098   }
35099
35100 }
35101
35102
35103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35104   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35105   Dali::Degree *arg2 = 0 ;
35106   Dali::Vector3 *arg3 = 0 ;
35107
35108   arg1 = (Dali::Actor *)jarg1;
35109   arg2 = (Dali::Degree *)jarg2;
35110   if (!arg2) {
35111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35112     return ;
35113   }
35114   arg3 = (Dali::Vector3 *)jarg3;
35115   if (!arg3) {
35116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35117     return ;
35118   }
35119   {
35120     try {
35121       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35122     } catch (std::out_of_range& e) {
35123       {
35124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35125       };
35126     } catch (std::exception& e) {
35127       {
35128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35129       };
35130     } catch (Dali::DaliException e) {
35131       {
35132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35133       };
35134     } catch (...) {
35135       {
35136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35137       };
35138     }
35139   }
35140
35141 }
35142
35143
35144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35145   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35146   Dali::Radian *arg2 = 0 ;
35147   Dali::Vector3 *arg3 = 0 ;
35148
35149   arg1 = (Dali::Actor *)jarg1;
35150   arg2 = (Dali::Radian *)jarg2;
35151   if (!arg2) {
35152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35153     return ;
35154   }
35155   arg3 = (Dali::Vector3 *)jarg3;
35156   if (!arg3) {
35157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35158     return ;
35159   }
35160   {
35161     try {
35162       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35163     } catch (std::out_of_range& e) {
35164       {
35165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35166       };
35167     } catch (std::exception& e) {
35168       {
35169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35170       };
35171     } catch (Dali::DaliException e) {
35172       {
35173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35174       };
35175     } catch (...) {
35176       {
35177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35178       };
35179     }
35180   }
35181
35182 }
35183
35184
35185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35186   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35187   Dali::Quaternion *arg2 = 0 ;
35188
35189   arg1 = (Dali::Actor *)jarg1;
35190   arg2 = (Dali::Quaternion *)jarg2;
35191   if (!arg2) {
35192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35193     return ;
35194   }
35195   {
35196     try {
35197       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35198     } catch (std::out_of_range& e) {
35199       {
35200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35201       };
35202     } catch (std::exception& e) {
35203       {
35204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35205       };
35206     } catch (Dali::DaliException e) {
35207       {
35208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35209       };
35210     } catch (...) {
35211       {
35212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35213       };
35214     }
35215   }
35216
35217 }
35218
35219
35220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35221   void * jresult ;
35222   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35223   Dali::Quaternion result;
35224
35225   arg1 = (Dali::Actor *)jarg1;
35226   {
35227     try {
35228       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35229     } catch (std::out_of_range& e) {
35230       {
35231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35232       };
35233     } catch (std::exception& e) {
35234       {
35235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35236       };
35237     } catch (Dali::DaliException e) {
35238       {
35239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35240       };
35241     } catch (...) {
35242       {
35243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35244       };
35245     }
35246   }
35247
35248   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35249   return jresult;
35250 }
35251
35252
35253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35254   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35255   bool arg2 ;
35256
35257   arg1 = (Dali::Actor *)jarg1;
35258   arg2 = jarg2 ? true : false;
35259   {
35260     try {
35261       (arg1)->SetInheritOrientation(arg2);
35262     } catch (std::out_of_range& e) {
35263       {
35264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35265       };
35266     } catch (std::exception& e) {
35267       {
35268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35269       };
35270     } catch (Dali::DaliException e) {
35271       {
35272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35273       };
35274     } catch (...) {
35275       {
35276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35277       };
35278     }
35279   }
35280
35281 }
35282
35283
35284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35285   unsigned int jresult ;
35286   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35287   bool result;
35288
35289   arg1 = (Dali::Actor *)jarg1;
35290   {
35291     try {
35292       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35293     } catch (std::out_of_range& e) {
35294       {
35295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35296       };
35297     } catch (std::exception& e) {
35298       {
35299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35300       };
35301     } catch (Dali::DaliException e) {
35302       {
35303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35304       };
35305     } catch (...) {
35306       {
35307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35308       };
35309     }
35310   }
35311
35312   jresult = result;
35313   return jresult;
35314 }
35315
35316
35317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35318   void * jresult ;
35319   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35320   Dali::Quaternion result;
35321
35322   arg1 = (Dali::Actor *)jarg1;
35323   {
35324     try {
35325       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35326     } catch (std::out_of_range& e) {
35327       {
35328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35329       };
35330     } catch (std::exception& e) {
35331       {
35332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35333       };
35334     } catch (Dali::DaliException e) {
35335       {
35336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35337       };
35338     } catch (...) {
35339       {
35340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35341       };
35342     }
35343   }
35344
35345   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35346   return jresult;
35347 }
35348
35349
35350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35351   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35352   float arg2 ;
35353
35354   arg1 = (Dali::Actor *)jarg1;
35355   arg2 = (float)jarg2;
35356   {
35357     try {
35358       (arg1)->SetScale(arg2);
35359     } catch (std::out_of_range& e) {
35360       {
35361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35362       };
35363     } catch (std::exception& e) {
35364       {
35365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35366       };
35367     } catch (Dali::DaliException e) {
35368       {
35369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35370       };
35371     } catch (...) {
35372       {
35373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35374       };
35375     }
35376   }
35377
35378 }
35379
35380
35381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35382   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35383   float arg2 ;
35384   float arg3 ;
35385   float arg4 ;
35386
35387   arg1 = (Dali::Actor *)jarg1;
35388   arg2 = (float)jarg2;
35389   arg3 = (float)jarg3;
35390   arg4 = (float)jarg4;
35391   {
35392     try {
35393       (arg1)->SetScale(arg2,arg3,arg4);
35394     } catch (std::out_of_range& e) {
35395       {
35396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35397       };
35398     } catch (std::exception& e) {
35399       {
35400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35401       };
35402     } catch (Dali::DaliException e) {
35403       {
35404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35405       };
35406     } catch (...) {
35407       {
35408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35409       };
35410     }
35411   }
35412
35413 }
35414
35415
35416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35417   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35418   Dali::Vector3 *arg2 = 0 ;
35419
35420   arg1 = (Dali::Actor *)jarg1;
35421   arg2 = (Dali::Vector3 *)jarg2;
35422   if (!arg2) {
35423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35424     return ;
35425   }
35426   {
35427     try {
35428       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35429     } catch (std::out_of_range& e) {
35430       {
35431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35432       };
35433     } catch (std::exception& e) {
35434       {
35435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35436       };
35437     } catch (Dali::DaliException e) {
35438       {
35439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35440       };
35441     } catch (...) {
35442       {
35443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35444       };
35445     }
35446   }
35447
35448 }
35449
35450
35451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35452   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35453   Dali::Vector3 *arg2 = 0 ;
35454
35455   arg1 = (Dali::Actor *)jarg1;
35456   arg2 = (Dali::Vector3 *)jarg2;
35457   if (!arg2) {
35458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35459     return ;
35460   }
35461   {
35462     try {
35463       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35464     } catch (std::out_of_range& e) {
35465       {
35466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35467       };
35468     } catch (std::exception& e) {
35469       {
35470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35471       };
35472     } catch (Dali::DaliException e) {
35473       {
35474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35475       };
35476     } catch (...) {
35477       {
35478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35479       };
35480     }
35481   }
35482
35483 }
35484
35485
35486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35487   void * jresult ;
35488   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35489   Dali::Vector3 result;
35490
35491   arg1 = (Dali::Actor *)jarg1;
35492   {
35493     try {
35494       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35495     } catch (std::out_of_range& e) {
35496       {
35497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35498       };
35499     } catch (std::exception& e) {
35500       {
35501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35502       };
35503     } catch (Dali::DaliException e) {
35504       {
35505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35506       };
35507     } catch (...) {
35508       {
35509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35510       };
35511     }
35512   }
35513
35514   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35515   return jresult;
35516 }
35517
35518
35519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35520   void * jresult ;
35521   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35522   Dali::Vector3 result;
35523
35524   arg1 = (Dali::Actor *)jarg1;
35525   {
35526     try {
35527       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35528     } catch (std::out_of_range& e) {
35529       {
35530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35531       };
35532     } catch (std::exception& e) {
35533       {
35534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35535       };
35536     } catch (Dali::DaliException e) {
35537       {
35538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35539       };
35540     } catch (...) {
35541       {
35542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35543       };
35544     }
35545   }
35546
35547   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35548   return jresult;
35549 }
35550
35551
35552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35553   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35554   bool arg2 ;
35555
35556   arg1 = (Dali::Actor *)jarg1;
35557   arg2 = jarg2 ? true : false;
35558   {
35559     try {
35560       (arg1)->SetInheritScale(arg2);
35561     } catch (std::out_of_range& e) {
35562       {
35563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35564       };
35565     } catch (std::exception& e) {
35566       {
35567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35568       };
35569     } catch (Dali::DaliException e) {
35570       {
35571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35572       };
35573     } catch (...) {
35574       {
35575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35576       };
35577     }
35578   }
35579
35580 }
35581
35582
35583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35584   unsigned int jresult ;
35585   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35586   bool result;
35587
35588   arg1 = (Dali::Actor *)jarg1;
35589   {
35590     try {
35591       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35592     } catch (std::out_of_range& e) {
35593       {
35594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35595       };
35596     } catch (std::exception& e) {
35597       {
35598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35599       };
35600     } catch (Dali::DaliException e) {
35601       {
35602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35603       };
35604     } catch (...) {
35605       {
35606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35607       };
35608     }
35609   }
35610
35611   jresult = result;
35612   return jresult;
35613 }
35614
35615
35616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35617   void * jresult ;
35618   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35619   Dali::Matrix result;
35620
35621   arg1 = (Dali::Actor *)jarg1;
35622   {
35623     try {
35624       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35625     } catch (std::out_of_range& e) {
35626       {
35627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35628       };
35629     } catch (std::exception& e) {
35630       {
35631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35632       };
35633     } catch (Dali::DaliException e) {
35634       {
35635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35636       };
35637     } catch (...) {
35638       {
35639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35640       };
35641     }
35642   }
35643
35644   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35645   return jresult;
35646 }
35647
35648
35649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35650   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35651   bool arg2 ;
35652
35653   arg1 = (Dali::Actor *)jarg1;
35654   arg2 = jarg2 ? true : false;
35655   {
35656     try {
35657       (arg1)->SetVisible(arg2);
35658     } catch (std::out_of_range& e) {
35659       {
35660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35661       };
35662     } catch (std::exception& e) {
35663       {
35664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35665       };
35666     } catch (Dali::DaliException e) {
35667       {
35668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35669       };
35670     } catch (...) {
35671       {
35672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35673       };
35674     }
35675   }
35676
35677 }
35678
35679
35680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35681   unsigned int jresult ;
35682   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35683   bool result;
35684
35685   arg1 = (Dali::Actor *)jarg1;
35686   {
35687     try {
35688       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35689     } catch (std::out_of_range& e) {
35690       {
35691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35692       };
35693     } catch (std::exception& e) {
35694       {
35695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35696       };
35697     } catch (Dali::DaliException e) {
35698       {
35699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35700       };
35701     } catch (...) {
35702       {
35703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35704       };
35705     }
35706   }
35707
35708   jresult = result;
35709   return jresult;
35710 }
35711
35712
35713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35714   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35715   float arg2 ;
35716
35717   arg1 = (Dali::Actor *)jarg1;
35718   arg2 = (float)jarg2;
35719   {
35720     try {
35721       (arg1)->SetOpacity(arg2);
35722     } catch (std::out_of_range& e) {
35723       {
35724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35725       };
35726     } catch (std::exception& e) {
35727       {
35728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35729       };
35730     } catch (Dali::DaliException e) {
35731       {
35732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35733       };
35734     } catch (...) {
35735       {
35736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35737       };
35738     }
35739   }
35740
35741 }
35742
35743
35744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35745   float jresult ;
35746   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35747   float result;
35748
35749   arg1 = (Dali::Actor *)jarg1;
35750   {
35751     try {
35752       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35753     } catch (std::out_of_range& e) {
35754       {
35755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35756       };
35757     } catch (std::exception& e) {
35758       {
35759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35760       };
35761     } catch (Dali::DaliException e) {
35762       {
35763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35764       };
35765     } catch (...) {
35766       {
35767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35768       };
35769     }
35770   }
35771
35772   jresult = result;
35773   return jresult;
35774 }
35775
35776
35777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35778   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35779   Dali::Vector4 *arg2 = 0 ;
35780
35781   arg1 = (Dali::Actor *)jarg1;
35782   arg2 = (Dali::Vector4 *)jarg2;
35783   if (!arg2) {
35784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35785     return ;
35786   }
35787   {
35788     try {
35789       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35790     } catch (std::out_of_range& e) {
35791       {
35792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35793       };
35794     } catch (std::exception& e) {
35795       {
35796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35797       };
35798     } catch (Dali::DaliException e) {
35799       {
35800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35801       };
35802     } catch (...) {
35803       {
35804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35805       };
35806     }
35807   }
35808
35809 }
35810
35811
35812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35813   void * jresult ;
35814   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35815   Dali::Vector4 result;
35816
35817   arg1 = (Dali::Actor *)jarg1;
35818   {
35819     try {
35820       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35821     } catch (std::out_of_range& e) {
35822       {
35823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35824       };
35825     } catch (std::exception& e) {
35826       {
35827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35828       };
35829     } catch (Dali::DaliException e) {
35830       {
35831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35832       };
35833     } catch (...) {
35834       {
35835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35836       };
35837     }
35838   }
35839
35840   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35841   return jresult;
35842 }
35843
35844
35845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35846   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35847   Dali::ColorMode arg2 ;
35848
35849   arg1 = (Dali::Actor *)jarg1;
35850   arg2 = (Dali::ColorMode)jarg2;
35851   {
35852     try {
35853       (arg1)->SetColorMode(arg2);
35854     } catch (std::out_of_range& e) {
35855       {
35856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35857       };
35858     } catch (std::exception& e) {
35859       {
35860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35861       };
35862     } catch (Dali::DaliException e) {
35863       {
35864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35865       };
35866     } catch (...) {
35867       {
35868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35869       };
35870     }
35871   }
35872
35873 }
35874
35875
35876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35877   int jresult ;
35878   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35879   Dali::ColorMode result;
35880
35881   arg1 = (Dali::Actor *)jarg1;
35882   {
35883     try {
35884       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35885     } catch (std::out_of_range& e) {
35886       {
35887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35888       };
35889     } catch (std::exception& e) {
35890       {
35891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35892       };
35893     } catch (Dali::DaliException e) {
35894       {
35895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35896       };
35897     } catch (...) {
35898       {
35899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35900       };
35901     }
35902   }
35903
35904   jresult = (int)result;
35905   return jresult;
35906 }
35907
35908
35909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35910   void * jresult ;
35911   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35912   Dali::Vector4 result;
35913
35914   arg1 = (Dali::Actor *)jarg1;
35915   {
35916     try {
35917       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35918     } catch (std::out_of_range& e) {
35919       {
35920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35921       };
35922     } catch (std::exception& e) {
35923       {
35924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35925       };
35926     } catch (Dali::DaliException e) {
35927       {
35928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35929       };
35930     } catch (...) {
35931       {
35932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35933       };
35934     }
35935   }
35936
35937   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35938   return jresult;
35939 }
35940
35941
35942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35944   Dali::DrawMode::Type arg2 ;
35945
35946   arg1 = (Dali::Actor *)jarg1;
35947   arg2 = (Dali::DrawMode::Type)jarg2;
35948   {
35949     try {
35950       (arg1)->SetDrawMode(arg2);
35951     } catch (std::out_of_range& e) {
35952       {
35953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35954       };
35955     } catch (std::exception& e) {
35956       {
35957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35958       };
35959     } catch (Dali::DaliException e) {
35960       {
35961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35962       };
35963     } catch (...) {
35964       {
35965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35966       };
35967     }
35968   }
35969
35970 }
35971
35972
35973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35974   int jresult ;
35975   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35976   Dali::DrawMode::Type result;
35977
35978   arg1 = (Dali::Actor *)jarg1;
35979   {
35980     try {
35981       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35982     } catch (std::out_of_range& e) {
35983       {
35984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35985       };
35986     } catch (std::exception& e) {
35987       {
35988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35989       };
35990     } catch (Dali::DaliException e) {
35991       {
35992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35993       };
35994     } catch (...) {
35995       {
35996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35997       };
35998     }
35999   }
36000
36001   jresult = (int)result;
36002   return jresult;
36003 }
36004
36005
36006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
36007   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36008   bool arg2 ;
36009
36010   arg1 = (Dali::Actor *)jarg1;
36011   arg2 = jarg2 ? true : false;
36012   {
36013     try {
36014       (arg1)->SetSensitive(arg2);
36015     } catch (std::out_of_range& e) {
36016       {
36017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36018       };
36019     } catch (std::exception& e) {
36020       {
36021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36022       };
36023     } catch (Dali::DaliException e) {
36024       {
36025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36026       };
36027     } catch (...) {
36028       {
36029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36030       };
36031     }
36032   }
36033
36034 }
36035
36036
36037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36038   unsigned int jresult ;
36039   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36040   bool result;
36041
36042   arg1 = (Dali::Actor *)jarg1;
36043   {
36044     try {
36045       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
36046     } catch (std::out_of_range& e) {
36047       {
36048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36049       };
36050     } catch (std::exception& e) {
36051       {
36052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36053       };
36054     } catch (Dali::DaliException e) {
36055       {
36056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36057       };
36058     } catch (...) {
36059       {
36060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36061       };
36062     }
36063   }
36064
36065   jresult = result;
36066   return jresult;
36067 }
36068
36069
36070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36071   unsigned int jresult ;
36072   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36073   float *arg2 = 0 ;
36074   float *arg3 = 0 ;
36075   float arg4 ;
36076   float arg5 ;
36077   bool result;
36078
36079   arg1 = (Dali::Actor *)jarg1;
36080   arg2 = (float *)jarg2;
36081   arg3 = (float *)jarg3;
36082   arg4 = (float)jarg4;
36083   arg5 = (float)jarg5;
36084   {
36085     try {
36086       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36087     } catch (std::out_of_range& e) {
36088       {
36089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36090       };
36091     } catch (std::exception& e) {
36092       {
36093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36094       };
36095     } catch (Dali::DaliException e) {
36096       {
36097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36098       };
36099     } catch (...) {
36100       {
36101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36102       };
36103     }
36104   }
36105
36106   jresult = result;
36107   return jresult;
36108 }
36109
36110
36111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36113   bool arg2 ;
36114
36115   arg1 = (Dali::Actor *)jarg1;
36116   arg2 = jarg2 ? true : false;
36117   {
36118     try {
36119       (arg1)->SetLeaveRequired(arg2);
36120     } catch (std::out_of_range& e) {
36121       {
36122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36123       };
36124     } catch (std::exception& e) {
36125       {
36126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36127       };
36128     } catch (Dali::DaliException e) {
36129       {
36130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36131       };
36132     } catch (...) {
36133       {
36134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36135       };
36136     }
36137   }
36138
36139 }
36140
36141
36142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36143   unsigned int jresult ;
36144   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36145   bool result;
36146
36147   arg1 = (Dali::Actor *)jarg1;
36148   {
36149     try {
36150       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36151     } catch (std::out_of_range& e) {
36152       {
36153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36154       };
36155     } catch (std::exception& e) {
36156       {
36157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36158       };
36159     } catch (Dali::DaliException e) {
36160       {
36161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36162       };
36163     } catch (...) {
36164       {
36165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36166       };
36167     }
36168   }
36169
36170   jresult = result;
36171   return jresult;
36172 }
36173
36174
36175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36176   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36177   bool arg2 ;
36178
36179   arg1 = (Dali::Actor *)jarg1;
36180   arg2 = jarg2 ? true : false;
36181   {
36182     try {
36183       (arg1)->SetKeyboardFocusable(arg2);
36184     } catch (std::out_of_range& e) {
36185       {
36186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36187       };
36188     } catch (std::exception& e) {
36189       {
36190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36191       };
36192     } catch (Dali::DaliException e) {
36193       {
36194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36195       };
36196     } catch (...) {
36197       {
36198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36199       };
36200     }
36201   }
36202
36203 }
36204
36205
36206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36207   unsigned int jresult ;
36208   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36209   bool result;
36210
36211   arg1 = (Dali::Actor *)jarg1;
36212   {
36213     try {
36214       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36215     } catch (std::out_of_range& e) {
36216       {
36217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36218       };
36219     } catch (std::exception& e) {
36220       {
36221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36222       };
36223     } catch (Dali::DaliException e) {
36224       {
36225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36226       };
36227     } catch (...) {
36228       {
36229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36230       };
36231     }
36232   }
36233
36234   jresult = result;
36235   return jresult;
36236 }
36237
36238
36239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36240   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36241   Dali::ResizePolicy::Type arg2 ;
36242   Dali::Dimension::Type arg3 ;
36243
36244   arg1 = (Dali::Actor *)jarg1;
36245   arg2 = (Dali::ResizePolicy::Type)jarg2;
36246   arg3 = (Dali::Dimension::Type)jarg3;
36247   {
36248     try {
36249       (arg1)->SetResizePolicy(arg2,arg3);
36250     } catch (std::out_of_range& e) {
36251       {
36252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36253       };
36254     } catch (std::exception& e) {
36255       {
36256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36257       };
36258     } catch (Dali::DaliException e) {
36259       {
36260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36261       };
36262     } catch (...) {
36263       {
36264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36265       };
36266     }
36267   }
36268
36269 }
36270
36271
36272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36273   int jresult ;
36274   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36275   Dali::Dimension::Type arg2 ;
36276   Dali::ResizePolicy::Type result;
36277
36278   arg1 = (Dali::Actor *)jarg1;
36279   arg2 = (Dali::Dimension::Type)jarg2;
36280   {
36281     try {
36282       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36283     } catch (std::out_of_range& e) {
36284       {
36285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36286       };
36287     } catch (std::exception& e) {
36288       {
36289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36290       };
36291     } catch (Dali::DaliException e) {
36292       {
36293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36294       };
36295     } catch (...) {
36296       {
36297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36298       };
36299     }
36300   }
36301
36302   jresult = (int)result;
36303   return jresult;
36304 }
36305
36306
36307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36308   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36309   Dali::SizeScalePolicy::Type arg2 ;
36310
36311   arg1 = (Dali::Actor *)jarg1;
36312   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36313   {
36314     try {
36315       (arg1)->SetSizeScalePolicy(arg2);
36316     } catch (std::out_of_range& e) {
36317       {
36318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36319       };
36320     } catch (std::exception& e) {
36321       {
36322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36323       };
36324     } catch (Dali::DaliException e) {
36325       {
36326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36327       };
36328     } catch (...) {
36329       {
36330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36331       };
36332     }
36333   }
36334
36335 }
36336
36337
36338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36339   int jresult ;
36340   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36341   Dali::SizeScalePolicy::Type result;
36342
36343   arg1 = (Dali::Actor *)jarg1;
36344   {
36345     try {
36346       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36347     } catch (std::out_of_range& e) {
36348       {
36349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36350       };
36351     } catch (std::exception& e) {
36352       {
36353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36354       };
36355     } catch (Dali::DaliException e) {
36356       {
36357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36358       };
36359     } catch (...) {
36360       {
36361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36362       };
36363     }
36364   }
36365
36366   jresult = (int)result;
36367   return jresult;
36368 }
36369
36370
36371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36372   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36373   Dali::Vector3 *arg2 = 0 ;
36374
36375   arg1 = (Dali::Actor *)jarg1;
36376   arg2 = (Dali::Vector3 *)jarg2;
36377   if (!arg2) {
36378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36379     return ;
36380   }
36381   {
36382     try {
36383       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36384     } catch (std::out_of_range& e) {
36385       {
36386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36387       };
36388     } catch (std::exception& e) {
36389       {
36390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36391       };
36392     } catch (Dali::DaliException e) {
36393       {
36394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36395       };
36396     } catch (...) {
36397       {
36398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36399       };
36400     }
36401   }
36402
36403 }
36404
36405
36406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36407   void * jresult ;
36408   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36409   Dali::Vector3 result;
36410
36411   arg1 = (Dali::Actor *)jarg1;
36412   {
36413     try {
36414       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36415     } catch (std::out_of_range& e) {
36416       {
36417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36418       };
36419     } catch (std::exception& e) {
36420       {
36421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36422       };
36423     } catch (Dali::DaliException e) {
36424       {
36425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36426       };
36427     } catch (...) {
36428       {
36429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36430       };
36431     }
36432   }
36433
36434   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36435   return jresult;
36436 }
36437
36438
36439 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36440   float jresult ;
36441   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36442   float arg2 ;
36443   float result;
36444
36445   arg1 = (Dali::Actor *)jarg1;
36446   arg2 = (float)jarg2;
36447   {
36448     try {
36449       result = (float)(arg1)->GetHeightForWidth(arg2);
36450     } catch (std::out_of_range& e) {
36451       {
36452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36453       };
36454     } catch (std::exception& e) {
36455       {
36456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36457       };
36458     } catch (Dali::DaliException e) {
36459       {
36460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36461       };
36462     } catch (...) {
36463       {
36464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36465       };
36466     }
36467   }
36468
36469   jresult = result;
36470   return jresult;
36471 }
36472
36473
36474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36475   float jresult ;
36476   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36477   float arg2 ;
36478   float result;
36479
36480   arg1 = (Dali::Actor *)jarg1;
36481   arg2 = (float)jarg2;
36482   {
36483     try {
36484       result = (float)(arg1)->GetWidthForHeight(arg2);
36485     } catch (std::out_of_range& e) {
36486       {
36487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36488       };
36489     } catch (std::exception& e) {
36490       {
36491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36492       };
36493     } catch (Dali::DaliException e) {
36494       {
36495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36496       };
36497     } catch (...) {
36498       {
36499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36500       };
36501     }
36502   }
36503
36504   jresult = result;
36505   return jresult;
36506 }
36507
36508
36509 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36510   float jresult ;
36511   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36512   Dali::Dimension::Type arg2 ;
36513   float result;
36514
36515   arg1 = (Dali::Actor *)jarg1;
36516   arg2 = (Dali::Dimension::Type)jarg2;
36517   {
36518     try {
36519       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36520     } catch (std::out_of_range& e) {
36521       {
36522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36523       };
36524     } catch (std::exception& e) {
36525       {
36526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36527       };
36528     } catch (Dali::DaliException e) {
36529       {
36530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36531       };
36532     } catch (...) {
36533       {
36534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36535       };
36536     }
36537   }
36538
36539   jresult = result;
36540   return jresult;
36541 }
36542
36543
36544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36545   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36546   Dali::Padding *arg2 = 0 ;
36547
36548   arg1 = (Dali::Actor *)jarg1;
36549   arg2 = (Dali::Padding *)jarg2;
36550   if (!arg2) {
36551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36552     return ;
36553   }
36554   {
36555     try {
36556       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36557     } catch (std::out_of_range& e) {
36558       {
36559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36560       };
36561     } catch (std::exception& e) {
36562       {
36563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36564       };
36565     } catch (Dali::DaliException e) {
36566       {
36567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36568       };
36569     } catch (...) {
36570       {
36571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36572       };
36573     }
36574   }
36575
36576 }
36577
36578
36579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36580   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36581   Dali::Padding *arg2 = 0 ;
36582
36583   arg1 = (Dali::Actor *)jarg1;
36584   arg2 = (Dali::Padding *)jarg2;
36585   if (!arg2) {
36586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36587     return ;
36588   }
36589   {
36590     try {
36591       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36592     } catch (std::out_of_range& e) {
36593       {
36594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36595       };
36596     } catch (std::exception& e) {
36597       {
36598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36599       };
36600     } catch (Dali::DaliException e) {
36601       {
36602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36603       };
36604     } catch (...) {
36605       {
36606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36607       };
36608     }
36609   }
36610
36611 }
36612
36613
36614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36615   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36616   Dali::Vector2 *arg2 = 0 ;
36617
36618   arg1 = (Dali::Actor *)jarg1;
36619   arg2 = (Dali::Vector2 *)jarg2;
36620   if (!arg2) {
36621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36622     return ;
36623   }
36624   {
36625     try {
36626       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36627     } catch (std::out_of_range& e) {
36628       {
36629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36630       };
36631     } catch (std::exception& e) {
36632       {
36633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36634       };
36635     } catch (Dali::DaliException e) {
36636       {
36637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36638       };
36639     } catch (...) {
36640       {
36641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36642       };
36643     }
36644   }
36645
36646 }
36647
36648
36649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36650   void * jresult ;
36651   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36652   Dali::Vector2 result;
36653
36654   arg1 = (Dali::Actor *)jarg1;
36655   {
36656     try {
36657       result = (arg1)->GetMinimumSize();
36658     } catch (std::out_of_range& e) {
36659       {
36660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36661       };
36662     } catch (std::exception& e) {
36663       {
36664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36665       };
36666     } catch (Dali::DaliException e) {
36667       {
36668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36669       };
36670     } catch (...) {
36671       {
36672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36673       };
36674     }
36675   }
36676
36677   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36678   return jresult;
36679 }
36680
36681
36682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36683   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36684   Dali::Vector2 *arg2 = 0 ;
36685
36686   arg1 = (Dali::Actor *)jarg1;
36687   arg2 = (Dali::Vector2 *)jarg2;
36688   if (!arg2) {
36689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36690     return ;
36691   }
36692   {
36693     try {
36694       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36695     } catch (std::out_of_range& e) {
36696       {
36697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36698       };
36699     } catch (std::exception& e) {
36700       {
36701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36702       };
36703     } catch (Dali::DaliException e) {
36704       {
36705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36706       };
36707     } catch (...) {
36708       {
36709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36710       };
36711     }
36712   }
36713
36714 }
36715
36716
36717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36718   void * jresult ;
36719   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36720   Dali::Vector2 result;
36721
36722   arg1 = (Dali::Actor *)jarg1;
36723   {
36724     try {
36725       result = (arg1)->GetMaximumSize();
36726     } catch (std::out_of_range& e) {
36727       {
36728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36729       };
36730     } catch (std::exception& e) {
36731       {
36732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36733       };
36734     } catch (Dali::DaliException e) {
36735       {
36736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36737       };
36738     } catch (...) {
36739       {
36740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36741       };
36742     }
36743   }
36744
36745   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36746   return jresult;
36747 }
36748
36749
36750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36751   int jresult ;
36752   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36753   int result;
36754
36755   arg1 = (Dali::Actor *)jarg1;
36756   {
36757     try {
36758       result = (int)(arg1)->GetHierarchyDepth();
36759       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36760     } catch (std::out_of_range& e) {
36761       {
36762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36763       };
36764     } catch (std::exception& e) {
36765       {
36766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36767       };
36768     } catch (Dali::DaliException e) {
36769       {
36770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36771       };
36772     } catch (...) {
36773       {
36774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36775       };
36776     }
36777   }
36778
36779   jresult = result;
36780   return jresult;
36781 }
36782
36783
36784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36785   unsigned int jresult ;
36786   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36787   Dali::Renderer *arg2 = 0 ;
36788   unsigned int result;
36789
36790   arg1 = (Dali::Actor *)jarg1;
36791   arg2 = (Dali::Renderer *)jarg2;
36792   if (!arg2) {
36793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36794     return 0;
36795   }
36796   {
36797     try {
36798       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36799     } catch (std::out_of_range& e) {
36800       {
36801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36802       };
36803     } catch (std::exception& e) {
36804       {
36805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36806       };
36807     } catch (Dali::DaliException e) {
36808       {
36809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36810       };
36811     } catch (...) {
36812       {
36813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36814       };
36815     }
36816   }
36817
36818   jresult = result;
36819   return jresult;
36820 }
36821
36822
36823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36824   unsigned int jresult ;
36825   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36826   unsigned int result;
36827
36828   arg1 = (Dali::Actor *)jarg1;
36829   {
36830     try {
36831       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36832     } catch (std::out_of_range& e) {
36833       {
36834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36835       };
36836     } catch (std::exception& e) {
36837       {
36838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36839       };
36840     } catch (Dali::DaliException e) {
36841       {
36842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36843       };
36844     } catch (...) {
36845       {
36846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36847       };
36848     }
36849   }
36850
36851   jresult = result;
36852   return jresult;
36853 }
36854
36855
36856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36857   void * jresult ;
36858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36859   unsigned int arg2 ;
36860   Dali::Renderer result;
36861
36862   arg1 = (Dali::Actor *)jarg1;
36863   arg2 = (unsigned int)jarg2;
36864   {
36865     try {
36866       result = (arg1)->GetRendererAt(arg2);
36867     } catch (std::out_of_range& e) {
36868       {
36869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36870       };
36871     } catch (std::exception& e) {
36872       {
36873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36874       };
36875     } catch (Dali::DaliException e) {
36876       {
36877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36878       };
36879     } catch (...) {
36880       {
36881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36882       };
36883     }
36884   }
36885
36886   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36887   return jresult;
36888 }
36889
36890
36891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36892   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36893   Dali::Renderer *arg2 = 0 ;
36894
36895   arg1 = (Dali::Actor *)jarg1;
36896   arg2 = (Dali::Renderer *)jarg2;
36897   if (!arg2) {
36898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36899     return ;
36900   }
36901   {
36902     try {
36903       (arg1)->RemoveRenderer(*arg2);
36904     } catch (std::out_of_range& e) {
36905       {
36906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36907       };
36908     } catch (std::exception& e) {
36909       {
36910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36911       };
36912     } catch (Dali::DaliException e) {
36913       {
36914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36915       };
36916     } catch (...) {
36917       {
36918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36919       };
36920     }
36921   }
36922
36923 }
36924
36925
36926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36927   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36928   unsigned int arg2 ;
36929
36930   arg1 = (Dali::Actor *)jarg1;
36931   arg2 = (unsigned int)jarg2;
36932   {
36933     try {
36934       (arg1)->RemoveRenderer(arg2);
36935     } catch (std::out_of_range& e) {
36936       {
36937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36938       };
36939     } catch (std::exception& e) {
36940       {
36941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36942       };
36943     } catch (Dali::DaliException e) {
36944       {
36945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36946       };
36947     } catch (...) {
36948       {
36949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36950       };
36951     }
36952   }
36953
36954 }
36955
36956
36957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36958   void * jresult ;
36959   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36960   Dali::Actor::TouchSignalType *result = 0 ;
36961
36962   arg1 = (Dali::Actor *)jarg1;
36963   {
36964     try {
36965       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36966     } catch (std::out_of_range& e) {
36967       {
36968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36969       };
36970     } catch (std::exception& e) {
36971       {
36972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36973       };
36974     } catch (Dali::DaliException e) {
36975       {
36976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36977       };
36978     } catch (...) {
36979       {
36980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36981       };
36982     }
36983   }
36984
36985   jresult = (void *)result;
36986   return jresult;
36987 }
36988
36989
36990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36991   void * jresult ;
36992   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36993   Dali::Actor::TouchDataSignalType *result = 0 ;
36994
36995   arg1 = (Dali::Actor *)jarg1;
36996   {
36997     try {
36998       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36999     } catch (std::out_of_range& e) {
37000       {
37001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37002       };
37003     } catch (std::exception& e) {
37004       {
37005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37006       };
37007     } catch (Dali::DaliException e) {
37008       {
37009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37010       };
37011     } catch (...) {
37012       {
37013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37014       };
37015     }
37016   }
37017
37018   jresult = (void *)result;
37019   return jresult;
37020 }
37021
37022
37023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
37024   void * jresult ;
37025   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37026   Dali::Actor::HoverSignalType *result = 0 ;
37027
37028   arg1 = (Dali::Actor *)jarg1;
37029   {
37030     try {
37031       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37032     } catch (std::out_of_range& e) {
37033       {
37034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37035       };
37036     } catch (std::exception& e) {
37037       {
37038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37039       };
37040     } catch (Dali::DaliException e) {
37041       {
37042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37043       };
37044     } catch (...) {
37045       {
37046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37047       };
37048     }
37049   }
37050
37051   jresult = (void *)result;
37052   return jresult;
37053 }
37054
37055
37056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37057   void * jresult ;
37058   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37059   Dali::Actor::WheelEventSignalType *result = 0 ;
37060
37061   arg1 = (Dali::Actor *)jarg1;
37062   {
37063     try {
37064       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37065     } catch (std::out_of_range& e) {
37066       {
37067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37068       };
37069     } catch (std::exception& e) {
37070       {
37071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37072       };
37073     } catch (Dali::DaliException e) {
37074       {
37075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37076       };
37077     } catch (...) {
37078       {
37079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37080       };
37081     }
37082   }
37083
37084   jresult = (void *)result;
37085   return jresult;
37086 }
37087
37088
37089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37090   void * jresult ;
37091   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37092   Dali::Actor::OnStageSignalType *result = 0 ;
37093
37094   arg1 = (Dali::Actor *)jarg1;
37095   {
37096     try {
37097       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37098     } catch (std::out_of_range& e) {
37099       {
37100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37101       };
37102     } catch (std::exception& e) {
37103       {
37104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37105       };
37106     } catch (Dali::DaliException e) {
37107       {
37108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37109       };
37110     } catch (...) {
37111       {
37112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37113       };
37114     }
37115   }
37116
37117   jresult = (void *)result;
37118   return jresult;
37119 }
37120
37121
37122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37123   void * jresult ;
37124   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37125   Dali::Actor::OffStageSignalType *result = 0 ;
37126
37127   arg1 = (Dali::Actor *)jarg1;
37128   {
37129     try {
37130       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37131     } catch (std::out_of_range& e) {
37132       {
37133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37134       };
37135     } catch (std::exception& e) {
37136       {
37137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37138       };
37139     } catch (Dali::DaliException e) {
37140       {
37141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37142       };
37143     } catch (...) {
37144       {
37145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37146       };
37147     }
37148   }
37149
37150   jresult = (void *)result;
37151   return jresult;
37152 }
37153
37154
37155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37156   void * jresult ;
37157   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37158   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37159
37160   arg1 = (Dali::Actor *)jarg1;
37161   {
37162     try {
37163       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37164     } catch (std::out_of_range& e) {
37165       {
37166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37167       };
37168     } catch (std::exception& e) {
37169       {
37170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37171       };
37172     } catch (Dali::DaliException e) {
37173       {
37174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37175       };
37176     } catch (...) {
37177       {
37178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37179       };
37180     }
37181   }
37182
37183   jresult = (void *)result;
37184   return jresult;
37185 }
37186
37187
37188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37189   Dali::Actor *arg1 = 0 ;
37190
37191   arg1 = (Dali::Actor *)jarg1;
37192   if (!arg1) {
37193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37194     return ;
37195   }
37196   {
37197     try {
37198       Dali::UnparentAndReset(*arg1);
37199     } catch (std::out_of_range& e) {
37200       {
37201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37202       };
37203     } catch (std::exception& e) {
37204       {
37205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37206       };
37207     } catch (Dali::DaliException e) {
37208       {
37209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37210       };
37211     } catch (...) {
37212       {
37213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37214       };
37215     }
37216   }
37217
37218 }
37219
37220
37221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37222   int jresult ;
37223   int result;
37224
37225   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37226   jresult = (int)result;
37227   return jresult;
37228 }
37229
37230
37231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37232   int jresult ;
37233   int result;
37234
37235   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37236   jresult = (int)result;
37237   return jresult;
37238 }
37239
37240
37241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37242   int jresult ;
37243   int result;
37244
37245   result = (int)Dali::Layer::Property::BEHAVIOR;
37246   jresult = (int)result;
37247   return jresult;
37248 }
37249
37250
37251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37252   void * jresult ;
37253   Dali::Layer::Property *result = 0 ;
37254
37255   {
37256     try {
37257       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37258     } catch (std::out_of_range& e) {
37259       {
37260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37261       };
37262     } catch (std::exception& e) {
37263       {
37264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37265       };
37266     } catch (Dali::DaliException e) {
37267       {
37268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37269       };
37270     } catch (...) {
37271       {
37272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37273       };
37274     }
37275   }
37276
37277   jresult = (void *)result;
37278   return jresult;
37279 }
37280
37281
37282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37283   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37284
37285   arg1 = (Dali::Layer::Property *)jarg1;
37286   {
37287     try {
37288       delete arg1;
37289     } catch (std::out_of_range& e) {
37290       {
37291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37292       };
37293     } catch (std::exception& e) {
37294       {
37295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37296       };
37297     } catch (Dali::DaliException e) {
37298       {
37299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37300       };
37301     } catch (...) {
37302       {
37303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37304       };
37305     }
37306   }
37307
37308 }
37309
37310
37311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37312   void * jresult ;
37313   Dali::Layer *result = 0 ;
37314
37315   {
37316     try {
37317       result = (Dali::Layer *)new Dali::Layer();
37318     } catch (std::out_of_range& e) {
37319       {
37320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37321       };
37322     } catch (std::exception& e) {
37323       {
37324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37325       };
37326     } catch (Dali::DaliException e) {
37327       {
37328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37329       };
37330     } catch (...) {
37331       {
37332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37333       };
37334     }
37335   }
37336
37337   jresult = (void *)result;
37338   return jresult;
37339 }
37340
37341
37342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37343   void * jresult ;
37344   Dali::Layer result;
37345
37346   {
37347     try {
37348       result = Dali::Layer::New();
37349     } catch (std::out_of_range& e) {
37350       {
37351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37352       };
37353     } catch (std::exception& e) {
37354       {
37355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37356       };
37357     } catch (Dali::DaliException e) {
37358       {
37359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37360       };
37361     } catch (...) {
37362       {
37363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37364       };
37365     }
37366   }
37367
37368   jresult = new Dali::Layer((const Dali::Layer &)result);
37369   return jresult;
37370 }
37371
37372
37373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37374   void * jresult ;
37375   Dali::BaseHandle arg1 ;
37376   Dali::BaseHandle *argp1 ;
37377   Dali::Layer result;
37378
37379   argp1 = (Dali::BaseHandle *)jarg1;
37380   if (!argp1) {
37381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37382     return 0;
37383   }
37384   arg1 = *argp1;
37385   {
37386     try {
37387       result = Dali::Layer::DownCast(arg1);
37388     } catch (std::out_of_range& e) {
37389       {
37390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37391       };
37392     } catch (std::exception& e) {
37393       {
37394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37395       };
37396     } catch (Dali::DaliException e) {
37397       {
37398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37399       };
37400     } catch (...) {
37401       {
37402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37403       };
37404     }
37405   }
37406
37407   jresult = new Dali::Layer((const Dali::Layer &)result);
37408   return jresult;
37409 }
37410
37411
37412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37413   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37414
37415   arg1 = (Dali::Layer *)jarg1;
37416   {
37417     try {
37418       delete arg1;
37419     } catch (std::out_of_range& e) {
37420       {
37421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37422       };
37423     } catch (std::exception& e) {
37424       {
37425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37426       };
37427     } catch (Dali::DaliException e) {
37428       {
37429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37430       };
37431     } catch (...) {
37432       {
37433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37434       };
37435     }
37436   }
37437
37438 }
37439
37440
37441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37442   void * jresult ;
37443   Dali::Layer *arg1 = 0 ;
37444   Dali::Layer *result = 0 ;
37445
37446   arg1 = (Dali::Layer *)jarg1;
37447   if (!arg1) {
37448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37449     return 0;
37450   }
37451   {
37452     try {
37453       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37454     } catch (std::out_of_range& e) {
37455       {
37456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37457       };
37458     } catch (std::exception& e) {
37459       {
37460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37461       };
37462     } catch (Dali::DaliException e) {
37463       {
37464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37465       };
37466     } catch (...) {
37467       {
37468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37469       };
37470     }
37471   }
37472
37473   jresult = (void *)result;
37474   return jresult;
37475 }
37476
37477
37478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37479   void * jresult ;
37480   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37481   Dali::Layer *arg2 = 0 ;
37482   Dali::Layer *result = 0 ;
37483
37484   arg1 = (Dali::Layer *)jarg1;
37485   arg2 = (Dali::Layer *)jarg2;
37486   if (!arg2) {
37487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37488     return 0;
37489   }
37490   {
37491     try {
37492       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37493     } catch (std::out_of_range& e) {
37494       {
37495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37496       };
37497     } catch (std::exception& e) {
37498       {
37499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37500       };
37501     } catch (Dali::DaliException e) {
37502       {
37503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37504       };
37505     } catch (...) {
37506       {
37507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37508       };
37509     }
37510   }
37511
37512   jresult = (void *)result;
37513   return jresult;
37514 }
37515
37516
37517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37518   unsigned int jresult ;
37519   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37520   unsigned int result;
37521
37522   arg1 = (Dali::Layer *)jarg1;
37523   {
37524     try {
37525       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37526     } catch (std::out_of_range& e) {
37527       {
37528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37529       };
37530     } catch (std::exception& e) {
37531       {
37532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37533       };
37534     } catch (Dali::DaliException e) {
37535       {
37536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37537       };
37538     } catch (...) {
37539       {
37540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37541       };
37542     }
37543   }
37544
37545   jresult = result;
37546   return jresult;
37547 }
37548
37549
37550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37551   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37552
37553   arg1 = (Dali::Layer *)jarg1;
37554   {
37555     try {
37556       (arg1)->Raise();
37557     } catch (std::out_of_range& e) {
37558       {
37559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37560       };
37561     } catch (std::exception& e) {
37562       {
37563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37564       };
37565     } catch (Dali::DaliException e) {
37566       {
37567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37568       };
37569     } catch (...) {
37570       {
37571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37572       };
37573     }
37574   }
37575
37576 }
37577
37578
37579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37580   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37581
37582   arg1 = (Dali::Layer *)jarg1;
37583   {
37584     try {
37585       (arg1)->Lower();
37586     } catch (std::out_of_range& e) {
37587       {
37588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37589       };
37590     } catch (std::exception& e) {
37591       {
37592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37593       };
37594     } catch (Dali::DaliException e) {
37595       {
37596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37597       };
37598     } catch (...) {
37599       {
37600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37601       };
37602     }
37603   }
37604
37605 }
37606
37607
37608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37609   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37610   Dali::Layer arg2 ;
37611   Dali::Layer *argp2 ;
37612
37613   arg1 = (Dali::Layer *)jarg1;
37614   argp2 = (Dali::Layer *)jarg2;
37615   if (!argp2) {
37616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37617     return ;
37618   }
37619   arg2 = *argp2;
37620   {
37621     try {
37622       (arg1)->RaiseAbove(arg2);
37623     } catch (std::out_of_range& e) {
37624       {
37625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37626       };
37627     } catch (std::exception& e) {
37628       {
37629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37630       };
37631     } catch (Dali::DaliException e) {
37632       {
37633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37634       };
37635     } catch (...) {
37636       {
37637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37638       };
37639     }
37640   }
37641
37642 }
37643
37644
37645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37646   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37647   Dali::Layer arg2 ;
37648   Dali::Layer *argp2 ;
37649
37650   arg1 = (Dali::Layer *)jarg1;
37651   argp2 = (Dali::Layer *)jarg2;
37652   if (!argp2) {
37653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37654     return ;
37655   }
37656   arg2 = *argp2;
37657   {
37658     try {
37659       (arg1)->LowerBelow(arg2);
37660     } catch (std::out_of_range& e) {
37661       {
37662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37663       };
37664     } catch (std::exception& e) {
37665       {
37666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37667       };
37668     } catch (Dali::DaliException e) {
37669       {
37670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37671       };
37672     } catch (...) {
37673       {
37674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37675       };
37676     }
37677   }
37678
37679 }
37680
37681
37682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37683   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37684
37685   arg1 = (Dali::Layer *)jarg1;
37686   {
37687     try {
37688       (arg1)->RaiseToTop();
37689     } catch (std::out_of_range& e) {
37690       {
37691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37692       };
37693     } catch (std::exception& e) {
37694       {
37695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37696       };
37697     } catch (Dali::DaliException e) {
37698       {
37699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37700       };
37701     } catch (...) {
37702       {
37703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37704       };
37705     }
37706   }
37707
37708 }
37709
37710
37711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37712   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37713
37714   arg1 = (Dali::Layer *)jarg1;
37715   {
37716     try {
37717       (arg1)->LowerToBottom();
37718     } catch (std::out_of_range& e) {
37719       {
37720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37721       };
37722     } catch (std::exception& e) {
37723       {
37724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37725       };
37726     } catch (Dali::DaliException e) {
37727       {
37728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37729       };
37730     } catch (...) {
37731       {
37732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37733       };
37734     }
37735   }
37736
37737 }
37738
37739
37740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37741   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37742   Dali::Layer arg2 ;
37743   Dali::Layer *argp2 ;
37744
37745   arg1 = (Dali::Layer *)jarg1;
37746   argp2 = (Dali::Layer *)jarg2;
37747   if (!argp2) {
37748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37749     return ;
37750   }
37751   arg2 = *argp2;
37752   {
37753     try {
37754       (arg1)->MoveAbove(arg2);
37755     } catch (std::out_of_range& e) {
37756       {
37757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37758       };
37759     } catch (std::exception& e) {
37760       {
37761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37762       };
37763     } catch (Dali::DaliException e) {
37764       {
37765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37766       };
37767     } catch (...) {
37768       {
37769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37770       };
37771     }
37772   }
37773
37774 }
37775
37776
37777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37778   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37779   Dali::Layer arg2 ;
37780   Dali::Layer *argp2 ;
37781
37782   arg1 = (Dali::Layer *)jarg1;
37783   argp2 = (Dali::Layer *)jarg2;
37784   if (!argp2) {
37785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37786     return ;
37787   }
37788   arg2 = *argp2;
37789   {
37790     try {
37791       (arg1)->MoveBelow(arg2);
37792     } catch (std::out_of_range& e) {
37793       {
37794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37795       };
37796     } catch (std::exception& e) {
37797       {
37798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37799       };
37800     } catch (Dali::DaliException e) {
37801       {
37802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37803       };
37804     } catch (...) {
37805       {
37806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37807       };
37808     }
37809   }
37810
37811 }
37812
37813
37814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37815   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37816   Dali::Layer::Behavior arg2 ;
37817
37818   arg1 = (Dali::Layer *)jarg1;
37819   arg2 = (Dali::Layer::Behavior)jarg2;
37820   {
37821     try {
37822       (arg1)->SetBehavior(arg2);
37823     } catch (std::out_of_range& e) {
37824       {
37825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37826       };
37827     } catch (std::exception& e) {
37828       {
37829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37830       };
37831     } catch (Dali::DaliException e) {
37832       {
37833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37834       };
37835     } catch (...) {
37836       {
37837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37838       };
37839     }
37840   }
37841
37842 }
37843
37844
37845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37846   int jresult ;
37847   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37848   Dali::Layer::Behavior result;
37849
37850   arg1 = (Dali::Layer *)jarg1;
37851   {
37852     try {
37853       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37854     } catch (std::out_of_range& e) {
37855       {
37856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37857       };
37858     } catch (std::exception& e) {
37859       {
37860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37861       };
37862     } catch (Dali::DaliException e) {
37863       {
37864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37865       };
37866     } catch (...) {
37867       {
37868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37869       };
37870     }
37871   }
37872
37873   jresult = (int)result;
37874   return jresult;
37875 }
37876
37877
37878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37879   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37880   bool arg2 ;
37881
37882   arg1 = (Dali::Layer *)jarg1;
37883   arg2 = jarg2 ? true : false;
37884   {
37885     try {
37886       (arg1)->SetClipping(arg2);
37887     } catch (std::out_of_range& e) {
37888       {
37889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37890       };
37891     } catch (std::exception& e) {
37892       {
37893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37894       };
37895     } catch (Dali::DaliException e) {
37896       {
37897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37898       };
37899     } catch (...) {
37900       {
37901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37902       };
37903     }
37904   }
37905
37906 }
37907
37908
37909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37910   unsigned int jresult ;
37911   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37912   bool result;
37913
37914   arg1 = (Dali::Layer *)jarg1;
37915   {
37916     try {
37917       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37918     } catch (std::out_of_range& e) {
37919       {
37920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37921       };
37922     } catch (std::exception& e) {
37923       {
37924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37925       };
37926     } catch (Dali::DaliException e) {
37927       {
37928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37929       };
37930     } catch (...) {
37931       {
37932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37933       };
37934     }
37935   }
37936
37937   jresult = result;
37938   return jresult;
37939 }
37940
37941
37942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37943   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37944   int arg2 ;
37945   int arg3 ;
37946   int arg4 ;
37947   int arg5 ;
37948
37949   arg1 = (Dali::Layer *)jarg1;
37950   arg2 = (int)jarg2;
37951   arg3 = (int)jarg3;
37952   arg4 = (int)jarg4;
37953   arg5 = (int)jarg5;
37954   {
37955     try {
37956       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37957     } catch (std::out_of_range& e) {
37958       {
37959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37960       };
37961     } catch (std::exception& e) {
37962       {
37963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37964       };
37965     } catch (Dali::DaliException e) {
37966       {
37967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37968       };
37969     } catch (...) {
37970       {
37971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37972       };
37973     }
37974   }
37975
37976 }
37977
37978
37979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37980   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37981   Dali::ClippingBox arg2 ;
37982   Dali::ClippingBox *argp2 ;
37983
37984   arg1 = (Dali::Layer *)jarg1;
37985   argp2 = (Dali::ClippingBox *)jarg2;
37986   if (!argp2) {
37987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37988     return ;
37989   }
37990   arg2 = *argp2;
37991   {
37992     try {
37993       (arg1)->SetClippingBox(arg2);
37994     } catch (std::out_of_range& e) {
37995       {
37996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37997       };
37998     } catch (std::exception& e) {
37999       {
38000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38001       };
38002     } catch (Dali::DaliException e) {
38003       {
38004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38005       };
38006     } catch (...) {
38007       {
38008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38009       };
38010     }
38011   }
38012
38013 }
38014
38015
38016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
38017   void * jresult ;
38018   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38019   Dali::ClippingBox result;
38020
38021   arg1 = (Dali::Layer *)jarg1;
38022   {
38023     try {
38024       result = ((Dali::Layer const *)arg1)->GetClippingBox();
38025     } catch (std::out_of_range& e) {
38026       {
38027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38028       };
38029     } catch (std::exception& e) {
38030       {
38031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38032       };
38033     } catch (Dali::DaliException e) {
38034       {
38035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38036       };
38037     } catch (...) {
38038       {
38039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38040       };
38041     }
38042   }
38043
38044   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38045   return jresult;
38046 }
38047
38048
38049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38050   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38051   bool arg2 ;
38052
38053   arg1 = (Dali::Layer *)jarg1;
38054   arg2 = jarg2 ? true : false;
38055   {
38056     try {
38057       (arg1)->SetDepthTestDisabled(arg2);
38058     } catch (std::out_of_range& e) {
38059       {
38060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38061       };
38062     } catch (std::exception& e) {
38063       {
38064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38065       };
38066     } catch (Dali::DaliException e) {
38067       {
38068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38069       };
38070     } catch (...) {
38071       {
38072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38073       };
38074     }
38075   }
38076
38077 }
38078
38079
38080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38081   unsigned int jresult ;
38082   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38083   bool result;
38084
38085   arg1 = (Dali::Layer *)jarg1;
38086   {
38087     try {
38088       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38089     } catch (std::out_of_range& e) {
38090       {
38091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38092       };
38093     } catch (std::exception& e) {
38094       {
38095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38096       };
38097     } catch (Dali::DaliException e) {
38098       {
38099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38100       };
38101     } catch (...) {
38102       {
38103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38104       };
38105     }
38106   }
38107
38108   jresult = result;
38109   return jresult;
38110 }
38111
38112
38113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38114   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38115   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38116
38117   arg1 = (Dali::Layer *)jarg1;
38118   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38119   {
38120     try {
38121       (arg1)->SetSortFunction(arg2);
38122     } catch (std::out_of_range& e) {
38123       {
38124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38125       };
38126     } catch (std::exception& e) {
38127       {
38128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38129       };
38130     } catch (Dali::DaliException e) {
38131       {
38132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38133       };
38134     } catch (...) {
38135       {
38136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38137       };
38138     }
38139   }
38140
38141 }
38142
38143
38144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38145   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38146   bool arg2 ;
38147
38148   arg1 = (Dali::Layer *)jarg1;
38149   arg2 = jarg2 ? true : false;
38150   {
38151     try {
38152       (arg1)->SetTouchConsumed(arg2);
38153     } catch (std::out_of_range& e) {
38154       {
38155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38156       };
38157     } catch (std::exception& e) {
38158       {
38159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38160       };
38161     } catch (Dali::DaliException e) {
38162       {
38163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38164       };
38165     } catch (...) {
38166       {
38167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38168       };
38169     }
38170   }
38171
38172 }
38173
38174
38175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38176   unsigned int jresult ;
38177   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38178   bool result;
38179
38180   arg1 = (Dali::Layer *)jarg1;
38181   {
38182     try {
38183       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38184     } catch (std::out_of_range& e) {
38185       {
38186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38187       };
38188     } catch (std::exception& e) {
38189       {
38190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38191       };
38192     } catch (Dali::DaliException e) {
38193       {
38194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38195       };
38196     } catch (...) {
38197       {
38198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38199       };
38200     }
38201   }
38202
38203   jresult = result;
38204   return jresult;
38205 }
38206
38207
38208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38209   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38210   bool arg2 ;
38211
38212   arg1 = (Dali::Layer *)jarg1;
38213   arg2 = jarg2 ? true : false;
38214   {
38215     try {
38216       (arg1)->SetHoverConsumed(arg2);
38217     } catch (std::out_of_range& e) {
38218       {
38219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38220       };
38221     } catch (std::exception& e) {
38222       {
38223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38224       };
38225     } catch (Dali::DaliException e) {
38226       {
38227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38228       };
38229     } catch (...) {
38230       {
38231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38232       };
38233     }
38234   }
38235
38236 }
38237
38238
38239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38240   unsigned int jresult ;
38241   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38242   bool result;
38243
38244   arg1 = (Dali::Layer *)jarg1;
38245   {
38246     try {
38247       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38248     } catch (std::out_of_range& e) {
38249       {
38250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38251       };
38252     } catch (std::exception& e) {
38253       {
38254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38255       };
38256     } catch (Dali::DaliException e) {
38257       {
38258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38259       };
38260     } catch (...) {
38261       {
38262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38263       };
38264     }
38265   }
38266
38267   jresult = result;
38268   return jresult;
38269 }
38270
38271
38272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38273   void * jresult ;
38274   Dali::Vector4 *result = 0 ;
38275
38276   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38277   jresult = (void *)result;
38278   return jresult;
38279 }
38280
38281
38282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38283   void * jresult ;
38284   Dali::Vector4 *result = 0 ;
38285
38286   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38287   jresult = (void *)result;
38288   return jresult;
38289 }
38290
38291
38292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38293   void * jresult ;
38294   Dali::Stage *result = 0 ;
38295
38296   {
38297     try {
38298       result = (Dali::Stage *)new Dali::Stage();
38299     } catch (std::out_of_range& e) {
38300       {
38301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38302       };
38303     } catch (std::exception& e) {
38304       {
38305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38306       };
38307     } catch (Dali::DaliException e) {
38308       {
38309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38310       };
38311     } catch (...) {
38312       {
38313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38314       };
38315     }
38316   }
38317
38318   jresult = (void *)result;
38319   return jresult;
38320 }
38321
38322
38323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38324   void * jresult ;
38325   Dali::Stage result;
38326
38327   {
38328     try {
38329       result = Dali::Stage::GetCurrent();
38330     } catch (std::out_of_range& e) {
38331       {
38332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38333       };
38334     } catch (std::exception& e) {
38335       {
38336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38337       };
38338     } catch (Dali::DaliException e) {
38339       {
38340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38341       };
38342     } catch (...) {
38343       {
38344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38345       };
38346     }
38347   }
38348
38349   jresult = new Dali::Stage((const Dali::Stage &)result);
38350   return jresult;
38351 }
38352
38353
38354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38355   unsigned int jresult ;
38356   bool result;
38357
38358   {
38359     try {
38360       result = (bool)Dali::Stage::IsInstalled();
38361     } catch (std::out_of_range& e) {
38362       {
38363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38364       };
38365     } catch (std::exception& e) {
38366       {
38367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38368       };
38369     } catch (Dali::DaliException e) {
38370       {
38371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38372       };
38373     } catch (...) {
38374       {
38375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38376       };
38377     }
38378   }
38379
38380   jresult = result;
38381   return jresult;
38382 }
38383
38384
38385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38386   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38387
38388   arg1 = (Dali::Stage *)jarg1;
38389   {
38390     try {
38391       delete arg1;
38392     } catch (std::out_of_range& e) {
38393       {
38394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38395       };
38396     } catch (std::exception& e) {
38397       {
38398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38399       };
38400     } catch (Dali::DaliException e) {
38401       {
38402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38403       };
38404     } catch (...) {
38405       {
38406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38407       };
38408     }
38409   }
38410
38411 }
38412
38413
38414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38415   void * jresult ;
38416   Dali::Stage *arg1 = 0 ;
38417   Dali::Stage *result = 0 ;
38418
38419   arg1 = (Dali::Stage *)jarg1;
38420   if (!arg1) {
38421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38422     return 0;
38423   }
38424   {
38425     try {
38426       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38427     } catch (std::out_of_range& e) {
38428       {
38429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38430       };
38431     } catch (std::exception& e) {
38432       {
38433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38434       };
38435     } catch (Dali::DaliException e) {
38436       {
38437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38438       };
38439     } catch (...) {
38440       {
38441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38442       };
38443     }
38444   }
38445
38446   jresult = (void *)result;
38447   return jresult;
38448 }
38449
38450
38451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38452   void * jresult ;
38453   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38454   Dali::Stage *arg2 = 0 ;
38455   Dali::Stage *result = 0 ;
38456
38457   arg1 = (Dali::Stage *)jarg1;
38458   arg2 = (Dali::Stage *)jarg2;
38459   if (!arg2) {
38460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38461     return 0;
38462   }
38463   {
38464     try {
38465       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38466     } catch (std::out_of_range& e) {
38467       {
38468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38469       };
38470     } catch (std::exception& e) {
38471       {
38472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38473       };
38474     } catch (Dali::DaliException e) {
38475       {
38476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38477       };
38478     } catch (...) {
38479       {
38480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38481       };
38482     }
38483   }
38484
38485   jresult = (void *)result;
38486   return jresult;
38487 }
38488
38489
38490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38491   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38492   Dali::Actor *arg2 = 0 ;
38493
38494   arg1 = (Dali::Stage *)jarg1;
38495   arg2 = (Dali::Actor *)jarg2;
38496   if (!arg2) {
38497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38498     return ;
38499   }
38500   {
38501     try {
38502       (arg1)->Add(*arg2);
38503     } catch (std::out_of_range& e) {
38504       {
38505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38506       };
38507     } catch (std::exception& e) {
38508       {
38509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38510       };
38511     } catch (Dali::DaliException e) {
38512       {
38513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38514       };
38515     } catch (...) {
38516       {
38517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38518       };
38519     }
38520   }
38521
38522 }
38523
38524
38525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38526   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38527   Dali::Actor *arg2 = 0 ;
38528
38529   arg1 = (Dali::Stage *)jarg1;
38530   arg2 = (Dali::Actor *)jarg2;
38531   if (!arg2) {
38532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38533     return ;
38534   }
38535   {
38536     try {
38537       (arg1)->Remove(*arg2);
38538     } catch (std::out_of_range& e) {
38539       {
38540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38541       };
38542     } catch (std::exception& e) {
38543       {
38544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38545       };
38546     } catch (Dali::DaliException e) {
38547       {
38548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38549       };
38550     } catch (...) {
38551       {
38552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38553       };
38554     }
38555   }
38556
38557 }
38558
38559
38560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38561   void * jresult ;
38562   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38563   Dali::Vector2 result;
38564
38565   arg1 = (Dali::Stage *)jarg1;
38566   {
38567     try {
38568       result = ((Dali::Stage const *)arg1)->GetSize();
38569     } catch (std::out_of_range& e) {
38570       {
38571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38572       };
38573     } catch (std::exception& e) {
38574       {
38575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38576       };
38577     } catch (Dali::DaliException e) {
38578       {
38579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38580       };
38581     } catch (...) {
38582       {
38583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38584       };
38585     }
38586   }
38587
38588   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38589   return jresult;
38590 }
38591
38592
38593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38594   void * jresult ;
38595   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38596   Dali::RenderTaskList result;
38597
38598   arg1 = (Dali::Stage *)jarg1;
38599   {
38600     try {
38601       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38602     } catch (std::out_of_range& e) {
38603       {
38604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38605       };
38606     } catch (std::exception& e) {
38607       {
38608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38609       };
38610     } catch (Dali::DaliException e) {
38611       {
38612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38613       };
38614     } catch (...) {
38615       {
38616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38617       };
38618     }
38619   }
38620
38621   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38622   return jresult;
38623 }
38624
38625
38626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38627   unsigned int jresult ;
38628   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38629   unsigned int result;
38630
38631   arg1 = (Dali::Stage *)jarg1;
38632   {
38633     try {
38634       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38635     } catch (std::out_of_range& e) {
38636       {
38637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38638       };
38639     } catch (std::exception& e) {
38640       {
38641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38642       };
38643     } catch (Dali::DaliException e) {
38644       {
38645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38646       };
38647     } catch (...) {
38648       {
38649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38650       };
38651     }
38652   }
38653
38654   jresult = result;
38655   return jresult;
38656 }
38657
38658
38659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38660   void * jresult ;
38661   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38662   unsigned int arg2 ;
38663   Dali::Layer result;
38664
38665   arg1 = (Dali::Stage *)jarg1;
38666   arg2 = (unsigned int)jarg2;
38667   {
38668     try {
38669       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38670     } catch (std::out_of_range& e) {
38671       {
38672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38673       };
38674     } catch (std::exception& e) {
38675       {
38676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38677       };
38678     } catch (Dali::DaliException e) {
38679       {
38680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38681       };
38682     } catch (...) {
38683       {
38684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38685       };
38686     }
38687   }
38688
38689   jresult = new Dali::Layer((const Dali::Layer &)result);
38690   return jresult;
38691 }
38692
38693
38694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38695   void * jresult ;
38696   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38697   Dali::Layer result;
38698
38699   arg1 = (Dali::Stage *)jarg1;
38700   {
38701     try {
38702       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38703     } catch (std::out_of_range& e) {
38704       {
38705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38706       };
38707     } catch (std::exception& e) {
38708       {
38709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38710       };
38711     } catch (Dali::DaliException e) {
38712       {
38713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38714       };
38715     } catch (...) {
38716       {
38717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38718       };
38719     }
38720   }
38721
38722   jresult = new Dali::Layer((const Dali::Layer &)result);
38723   return jresult;
38724 }
38725
38726
38727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38728   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38729   Dali::Vector4 arg2 ;
38730   Dali::Vector4 *argp2 ;
38731
38732   arg1 = (Dali::Stage *)jarg1;
38733   argp2 = (Dali::Vector4 *)jarg2;
38734   if (!argp2) {
38735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38736     return ;
38737   }
38738   arg2 = *argp2;
38739   {
38740     try {
38741       (arg1)->SetBackgroundColor(arg2);
38742     } catch (std::out_of_range& e) {
38743       {
38744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38745       };
38746     } catch (std::exception& e) {
38747       {
38748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38749       };
38750     } catch (Dali::DaliException e) {
38751       {
38752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38753       };
38754     } catch (...) {
38755       {
38756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38757       };
38758     }
38759   }
38760
38761 }
38762
38763
38764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38765   void * jresult ;
38766   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38767   Dali::Vector4 result;
38768
38769   arg1 = (Dali::Stage *)jarg1;
38770   {
38771     try {
38772       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38773     } catch (std::out_of_range& e) {
38774       {
38775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38776       };
38777     } catch (std::exception& e) {
38778       {
38779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38780       };
38781     } catch (Dali::DaliException e) {
38782       {
38783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38784       };
38785     } catch (...) {
38786       {
38787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38788       };
38789     }
38790   }
38791
38792   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38793   return jresult;
38794 }
38795
38796
38797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38798   void * jresult ;
38799   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38800   Dali::Vector2 result;
38801
38802   arg1 = (Dali::Stage *)jarg1;
38803   {
38804     try {
38805       result = ((Dali::Stage const *)arg1)->GetDpi();
38806     } catch (std::out_of_range& e) {
38807       {
38808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38809       };
38810     } catch (std::exception& e) {
38811       {
38812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38813       };
38814     } catch (Dali::DaliException e) {
38815       {
38816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38817       };
38818     } catch (...) {
38819       {
38820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38821       };
38822     }
38823   }
38824
38825   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38826   return jresult;
38827 }
38828
38829
38830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38831   void * jresult ;
38832   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38833   Dali::ObjectRegistry result;
38834
38835   arg1 = (Dali::Stage *)jarg1;
38836   {
38837     try {
38838       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38839     } catch (std::out_of_range& e) {
38840       {
38841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38842       };
38843     } catch (std::exception& e) {
38844       {
38845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38846       };
38847     } catch (Dali::DaliException e) {
38848       {
38849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38850       };
38851     } catch (...) {
38852       {
38853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38854       };
38855     }
38856   }
38857
38858   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38859   return jresult;
38860 }
38861
38862
38863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38864   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38865   float arg2 ;
38866
38867   arg1 = (Dali::Stage *)jarg1;
38868   arg2 = (float)jarg2;
38869   {
38870     try {
38871       (arg1)->KeepRendering(arg2);
38872     } catch (std::out_of_range& e) {
38873       {
38874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38875       };
38876     } catch (std::exception& e) {
38877       {
38878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38879       };
38880     } catch (Dali::DaliException e) {
38881       {
38882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38883       };
38884     } catch (...) {
38885       {
38886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38887       };
38888     }
38889   }
38890
38891 }
38892
38893
38894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38895   void * jresult ;
38896   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38897   Dali::Stage::KeyEventSignalType *result = 0 ;
38898
38899   arg1 = (Dali::Stage *)jarg1;
38900   {
38901     try {
38902       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38903     } catch (std::out_of_range& e) {
38904       {
38905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38906       };
38907     } catch (std::exception& e) {
38908       {
38909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38910       };
38911     } catch (Dali::DaliException e) {
38912       {
38913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38914       };
38915     } catch (...) {
38916       {
38917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38918       };
38919     }
38920   }
38921
38922   jresult = (void *)result;
38923   return jresult;
38924 }
38925
38926
38927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38928   void * jresult ;
38929   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38930   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38931
38932   arg1 = (Dali::Stage *)jarg1;
38933   {
38934     try {
38935       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38936     } catch (std::out_of_range& e) {
38937       {
38938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38939       };
38940     } catch (std::exception& e) {
38941       {
38942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38943       };
38944     } catch (Dali::DaliException e) {
38945       {
38946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38947       };
38948     } catch (...) {
38949       {
38950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38951       };
38952     }
38953   }
38954
38955   jresult = (void *)result;
38956   return jresult;
38957 }
38958
38959
38960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38961   void * jresult ;
38962   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38963   Dali::Stage::TouchSignalType *result = 0 ;
38964
38965   arg1 = (Dali::Stage *)jarg1;
38966   {
38967     try {
38968       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38969     } catch (std::out_of_range& e) {
38970       {
38971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38972       };
38973     } catch (std::exception& e) {
38974       {
38975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38976       };
38977     } catch (Dali::DaliException e) {
38978       {
38979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38980       };
38981     } catch (...) {
38982       {
38983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38984       };
38985     }
38986   }
38987
38988   jresult = (void *)result;
38989   return jresult;
38990 }
38991
38992
38993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38994   void * jresult ;
38995   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38996   Dali::Stage::WheelEventSignalType *result = 0 ;
38997
38998   arg1 = (Dali::Stage *)jarg1;
38999   {
39000     try {
39001       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
39002     } catch (std::out_of_range& e) {
39003       {
39004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39005       };
39006     } catch (std::exception& e) {
39007       {
39008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39009       };
39010     } catch (Dali::DaliException e) {
39011       {
39012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39013       };
39014     } catch (...) {
39015       {
39016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39017       };
39018     }
39019   }
39020
39021   jresult = (void *)result;
39022   return jresult;
39023 }
39024
39025
39026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
39027   void * jresult ;
39028   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39029   Dali::Stage::ContextStatusSignal *result = 0 ;
39030
39031   arg1 = (Dali::Stage *)jarg1;
39032   {
39033     try {
39034       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
39035     } catch (std::out_of_range& e) {
39036       {
39037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39038       };
39039     } catch (std::exception& e) {
39040       {
39041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39042       };
39043     } catch (Dali::DaliException e) {
39044       {
39045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39046       };
39047     } catch (...) {
39048       {
39049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39050       };
39051     }
39052   }
39053
39054   jresult = (void *)result;
39055   return jresult;
39056 }
39057
39058
39059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39060   void * jresult ;
39061   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39062   Dali::Stage::ContextStatusSignal *result = 0 ;
39063
39064   arg1 = (Dali::Stage *)jarg1;
39065   {
39066     try {
39067       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39068     } catch (std::out_of_range& e) {
39069       {
39070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39071       };
39072     } catch (std::exception& e) {
39073       {
39074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39075       };
39076     } catch (Dali::DaliException e) {
39077       {
39078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39079       };
39080     } catch (...) {
39081       {
39082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39083       };
39084     }
39085   }
39086
39087   jresult = (void *)result;
39088   return jresult;
39089 }
39090
39091
39092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39093   void * jresult ;
39094   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39095   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39096
39097   arg1 = (Dali::Stage *)jarg1;
39098   {
39099     try {
39100       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39101     } catch (std::out_of_range& e) {
39102       {
39103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39104       };
39105     } catch (std::exception& e) {
39106       {
39107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39108       };
39109     } catch (Dali::DaliException e) {
39110       {
39111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39112       };
39113     } catch (...) {
39114       {
39115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39116       };
39117     }
39118   }
39119
39120   jresult = (void *)result;
39121   return jresult;
39122 }
39123
39124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39125   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39126   Dali::DevelStage::Rendering arg2 ;
39127
39128   arg1 = (Dali::Stage *)jarg1;
39129   arg2 = (Dali::DevelStage::Rendering)jarg2;
39130   {
39131     try {
39132       DevelStage::SetRenderingBehavior(*arg1,arg2);
39133     } catch (std::out_of_range& e) {
39134       {
39135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39136       };
39137     } catch (std::exception& e) {
39138       {
39139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39140       };
39141     } catch (Dali::DaliException e) {
39142       {
39143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39144       };
39145     } catch (...) {
39146       {
39147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39148       };
39149     }
39150   }
39151
39152 }
39153
39154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39155
39156   int jresult ;
39157   int result ;
39158   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39159
39160   arg1 = (Dali::Stage *)jarg1;
39161   {
39162     try {
39163       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39164     } catch (std::out_of_range& e) {
39165       {
39166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39167       };
39168     } catch (std::exception& e) {
39169       {
39170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39171       };
39172     } catch (Dali::DaliException e) {
39173       {
39174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39175       };
39176     } catch (...) {
39177       {
39178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39179       };
39180     }
39181   }
39182
39183   jresult = result;
39184   return jresult;
39185 }
39186
39187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39188   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39189
39190   arg1 = (Dali::RelayoutContainer *)jarg1;
39191   {
39192     try {
39193       delete arg1;
39194     } catch (std::out_of_range& e) {
39195       {
39196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39197       };
39198     } catch (std::exception& e) {
39199       {
39200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39201       };
39202     } catch (Dali::DaliException e) {
39203       {
39204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39205       };
39206     } catch (...) {
39207       {
39208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39209       };
39210     }
39211   }
39212
39213 }
39214
39215
39216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39217   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39218   Dali::Actor *arg2 = 0 ;
39219   Dali::Vector2 *arg3 = 0 ;
39220
39221   arg1 = (Dali::RelayoutContainer *)jarg1;
39222   arg2 = (Dali::Actor *)jarg2;
39223   if (!arg2) {
39224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39225     return ;
39226   }
39227   arg3 = (Dali::Vector2 *)jarg3;
39228   if (!arg3) {
39229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39230     return ;
39231   }
39232   {
39233     try {
39234       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39235     } catch (std::out_of_range& e) {
39236       {
39237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39238       };
39239     } catch (std::exception& e) {
39240       {
39241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39242       };
39243     } catch (Dali::DaliException e) {
39244       {
39245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39246       };
39247     } catch (...) {
39248       {
39249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39250       };
39251     }
39252   }
39253
39254 }
39255
39256
39257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39258   void * jresult ;
39259   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39260   Dali::CustomActor result;
39261
39262   arg1 = (Dali::CustomActorImpl *)jarg1;
39263   {
39264     try {
39265       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39266     } catch (std::out_of_range& e) {
39267       {
39268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39269       };
39270     } catch (std::exception& e) {
39271       {
39272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39273       };
39274     } catch (Dali::DaliException e) {
39275       {
39276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39277       };
39278     } catch (...) {
39279       {
39280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39281       };
39282     }
39283   }
39284
39285   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39286   return jresult;
39287 }
39288
39289
39290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39291   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39292   int arg2 ;
39293
39294   arg1 = (Dali::CustomActorImpl *)jarg1;
39295   arg2 = (int)jarg2;
39296   {
39297     try {
39298       (arg1)->OnStageConnection(arg2);
39299     } catch (std::out_of_range& e) {
39300       {
39301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39302       };
39303     } catch (std::exception& e) {
39304       {
39305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39306       };
39307     } catch (Dali::DaliException e) {
39308       {
39309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39310       };
39311     } catch (...) {
39312       {
39313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39314       };
39315     }
39316   }
39317
39318 }
39319
39320
39321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39322   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39323
39324   arg1 = (Dali::CustomActorImpl *)jarg1;
39325   {
39326     try {
39327       (arg1)->OnStageDisconnection();
39328     } catch (std::out_of_range& e) {
39329       {
39330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39331       };
39332     } catch (std::exception& e) {
39333       {
39334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39335       };
39336     } catch (Dali::DaliException e) {
39337       {
39338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39339       };
39340     } catch (...) {
39341       {
39342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39343       };
39344     }
39345   }
39346
39347 }
39348
39349
39350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39351   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39352   Dali::Actor *arg2 = 0 ;
39353
39354   arg1 = (Dali::CustomActorImpl *)jarg1;
39355   arg2 = (Dali::Actor *)jarg2;
39356   if (!arg2) {
39357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39358     return ;
39359   }
39360   {
39361     try {
39362       (arg1)->OnChildAdd(*arg2);
39363     } catch (std::out_of_range& e) {
39364       {
39365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39366       };
39367     } catch (std::exception& e) {
39368       {
39369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39370       };
39371     } catch (Dali::DaliException e) {
39372       {
39373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39374       };
39375     } catch (...) {
39376       {
39377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39378       };
39379     }
39380   }
39381
39382 }
39383
39384
39385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39386   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39387   Dali::Actor *arg2 = 0 ;
39388
39389   arg1 = (Dali::CustomActorImpl *)jarg1;
39390   arg2 = (Dali::Actor *)jarg2;
39391   if (!arg2) {
39392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39393     return ;
39394   }
39395   {
39396     try {
39397       (arg1)->OnChildRemove(*arg2);
39398     } catch (std::out_of_range& e) {
39399       {
39400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39401       };
39402     } catch (std::exception& e) {
39403       {
39404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39405       };
39406     } catch (Dali::DaliException e) {
39407       {
39408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39409       };
39410     } catch (...) {
39411       {
39412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39413       };
39414     }
39415   }
39416
39417 }
39418
39419
39420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39421   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39422   Dali::Property::Index arg2 ;
39423   Dali::Property::Value arg3 ;
39424   Dali::Property::Value *argp3 ;
39425
39426   arg1 = (Dali::CustomActorImpl *)jarg1;
39427   arg2 = (Dali::Property::Index)jarg2;
39428   argp3 = (Dali::Property::Value *)jarg3;
39429   if (!argp3) {
39430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39431     return ;
39432   }
39433   arg3 = *argp3;
39434   {
39435     try {
39436       (arg1)->OnPropertySet(arg2,arg3);
39437     } catch (std::out_of_range& e) {
39438       {
39439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39440       };
39441     } catch (std::exception& e) {
39442       {
39443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39444       };
39445     } catch (Dali::DaliException e) {
39446       {
39447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39448       };
39449     } catch (...) {
39450       {
39451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39452       };
39453     }
39454   }
39455
39456 }
39457
39458
39459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39460   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39461   Dali::Vector3 *arg2 = 0 ;
39462
39463   arg1 = (Dali::CustomActorImpl *)jarg1;
39464   arg2 = (Dali::Vector3 *)jarg2;
39465   if (!arg2) {
39466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39467     return ;
39468   }
39469   {
39470     try {
39471       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39472     } catch (std::out_of_range& e) {
39473       {
39474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39475       };
39476     } catch (std::exception& e) {
39477       {
39478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39479       };
39480     } catch (Dali::DaliException e) {
39481       {
39482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39483       };
39484     } catch (...) {
39485       {
39486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39487       };
39488     }
39489   }
39490
39491 }
39492
39493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39494   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39495   Dali::Animation *arg2 = 0 ;
39496   Dali::Vector3 *arg3 = 0 ;
39497
39498   arg1 = (Dali::CustomActorImpl *)jarg1;
39499   arg2 = (Dali::Animation *)jarg2;
39500   if (!arg2) {
39501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39502     return ;
39503   }
39504   arg3 = (Dali::Vector3 *)jarg3;
39505   if (!arg3) {
39506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39507     return ;
39508   }
39509   {
39510     try {
39511       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39512     } catch (std::out_of_range& e) {
39513       {
39514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39515       };
39516     } catch (std::exception& e) {
39517       {
39518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39519       };
39520     } catch (Dali::DaliException e) {
39521       {
39522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39523       };
39524     } catch (...) {
39525       {
39526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39527       };
39528     }
39529   }
39530
39531 }
39532
39533
39534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39535   unsigned int jresult ;
39536   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39537   Dali::TouchEvent *arg2 = 0 ;
39538   bool result;
39539
39540   arg1 = (Dali::CustomActorImpl *)jarg1;
39541   arg2 = (Dali::TouchEvent *)jarg2;
39542   if (!arg2) {
39543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39544     return 0;
39545   }
39546   {
39547     try {
39548       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39549     } catch (std::out_of_range& e) {
39550       {
39551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39552       };
39553     } catch (std::exception& e) {
39554       {
39555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39556       };
39557     } catch (Dali::DaliException e) {
39558       {
39559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39560       };
39561     } catch (...) {
39562       {
39563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39564       };
39565     }
39566   }
39567
39568   jresult = result;
39569   return jresult;
39570 }
39571
39572
39573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39574   unsigned int jresult ;
39575   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39576   Dali::HoverEvent *arg2 = 0 ;
39577   bool result;
39578
39579   arg1 = (Dali::CustomActorImpl *)jarg1;
39580   arg2 = (Dali::HoverEvent *)jarg2;
39581   if (!arg2) {
39582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39583     return 0;
39584   }
39585   {
39586     try {
39587       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39588     } catch (std::out_of_range& e) {
39589       {
39590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39591       };
39592     } catch (std::exception& e) {
39593       {
39594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39595       };
39596     } catch (Dali::DaliException e) {
39597       {
39598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39599       };
39600     } catch (...) {
39601       {
39602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39603       };
39604     }
39605   }
39606
39607   jresult = result;
39608   return jresult;
39609 }
39610
39611
39612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39613   unsigned int jresult ;
39614   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39615   Dali::KeyEvent *arg2 = 0 ;
39616   bool result;
39617
39618   arg1 = (Dali::CustomActorImpl *)jarg1;
39619   arg2 = (Dali::KeyEvent *)jarg2;
39620   if (!arg2) {
39621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39622     return 0;
39623   }
39624   {
39625     try {
39626       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39627     } catch (std::out_of_range& e) {
39628       {
39629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39630       };
39631     } catch (std::exception& e) {
39632       {
39633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39634       };
39635     } catch (Dali::DaliException e) {
39636       {
39637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39638       };
39639     } catch (...) {
39640       {
39641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39642       };
39643     }
39644   }
39645
39646   jresult = result;
39647   return jresult;
39648 }
39649
39650
39651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39652   unsigned int jresult ;
39653   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39654   Dali::WheelEvent *arg2 = 0 ;
39655   bool result;
39656
39657   arg1 = (Dali::CustomActorImpl *)jarg1;
39658   arg2 = (Dali::WheelEvent *)jarg2;
39659   if (!arg2) {
39660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39661     return 0;
39662   }
39663   {
39664     try {
39665       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39666     } catch (std::out_of_range& e) {
39667       {
39668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39669       };
39670     } catch (std::exception& e) {
39671       {
39672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39673       };
39674     } catch (Dali::DaliException e) {
39675       {
39676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39677       };
39678     } catch (...) {
39679       {
39680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39681       };
39682     }
39683   }
39684
39685   jresult = result;
39686   return jresult;
39687 }
39688
39689
39690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39691   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39692   Dali::Vector2 *arg2 = 0 ;
39693   Dali::RelayoutContainer *arg3 = 0 ;
39694
39695   arg1 = (Dali::CustomActorImpl *)jarg1;
39696   arg2 = (Dali::Vector2 *)jarg2;
39697   if (!arg2) {
39698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39699     return ;
39700   }
39701   arg3 = (Dali::RelayoutContainer *)jarg3;
39702   if (!arg3) {
39703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39704     return ;
39705   }
39706   {
39707     try {
39708       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39709     } catch (std::out_of_range& e) {
39710       {
39711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39712       };
39713     } catch (std::exception& e) {
39714       {
39715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39716       };
39717     } catch (Dali::DaliException e) {
39718       {
39719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39720       };
39721     } catch (...) {
39722       {
39723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39724       };
39725     }
39726   }
39727
39728 }
39729
39730
39731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39732   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39733   Dali::ResizePolicy::Type arg2 ;
39734   Dali::Dimension::Type arg3 ;
39735
39736   arg1 = (Dali::CustomActorImpl *)jarg1;
39737   arg2 = (Dali::ResizePolicy::Type)jarg2;
39738   arg3 = (Dali::Dimension::Type)jarg3;
39739   {
39740     try {
39741       (arg1)->OnSetResizePolicy(arg2,arg3);
39742     } catch (std::out_of_range& e) {
39743       {
39744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39745       };
39746     } catch (std::exception& e) {
39747       {
39748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39749       };
39750     } catch (Dali::DaliException e) {
39751       {
39752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39753       };
39754     } catch (...) {
39755       {
39756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39757       };
39758     }
39759   }
39760
39761 }
39762
39763
39764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39765   void * jresult ;
39766   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39767   Dali::Vector3 result;
39768
39769   arg1 = (Dali::CustomActorImpl *)jarg1;
39770   {
39771     try {
39772       result = (arg1)->GetNaturalSize();
39773     } catch (std::out_of_range& e) {
39774       {
39775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39776       };
39777     } catch (std::exception& e) {
39778       {
39779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39780       };
39781     } catch (Dali::DaliException e) {
39782       {
39783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39784       };
39785     } catch (...) {
39786       {
39787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39788       };
39789     }
39790   }
39791
39792   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39793   return jresult;
39794 }
39795
39796
39797 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39798   float jresult ;
39799   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39800   Dali::Actor *arg2 = 0 ;
39801   Dali::Dimension::Type arg3 ;
39802   float result;
39803
39804   arg1 = (Dali::CustomActorImpl *)jarg1;
39805   arg2 = (Dali::Actor *)jarg2;
39806   if (!arg2) {
39807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39808     return 0;
39809   }
39810   arg3 = (Dali::Dimension::Type)jarg3;
39811   {
39812     try {
39813       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39814     } catch (std::out_of_range& e) {
39815       {
39816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39817       };
39818     } catch (std::exception& e) {
39819       {
39820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39821       };
39822     } catch (Dali::DaliException e) {
39823       {
39824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39825       };
39826     } catch (...) {
39827       {
39828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39829       };
39830     }
39831   }
39832
39833   jresult = result;
39834   return jresult;
39835 }
39836
39837
39838 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39839   float jresult ;
39840   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39841   float arg2 ;
39842   float result;
39843
39844   arg1 = (Dali::CustomActorImpl *)jarg1;
39845   arg2 = (float)jarg2;
39846   {
39847     try {
39848       result = (float)(arg1)->GetHeightForWidth(arg2);
39849     } catch (std::out_of_range& e) {
39850       {
39851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39852       };
39853     } catch (std::exception& e) {
39854       {
39855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39856       };
39857     } catch (Dali::DaliException e) {
39858       {
39859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39860       };
39861     } catch (...) {
39862       {
39863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39864       };
39865     }
39866   }
39867
39868   jresult = result;
39869   return jresult;
39870 }
39871
39872
39873 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39874   float jresult ;
39875   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39876   float arg2 ;
39877   float result;
39878
39879   arg1 = (Dali::CustomActorImpl *)jarg1;
39880   arg2 = (float)jarg2;
39881   {
39882     try {
39883       result = (float)(arg1)->GetWidthForHeight(arg2);
39884     } catch (std::out_of_range& e) {
39885       {
39886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39887       };
39888     } catch (std::exception& e) {
39889       {
39890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39891       };
39892     } catch (Dali::DaliException e) {
39893       {
39894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39895       };
39896     } catch (...) {
39897       {
39898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39899       };
39900     }
39901   }
39902
39903   jresult = result;
39904   return jresult;
39905 }
39906
39907
39908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39909   unsigned int jresult ;
39910   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39911   Dali::Dimension::Type arg2 ;
39912   bool result;
39913
39914   arg1 = (Dali::CustomActorImpl *)jarg1;
39915   arg2 = (Dali::Dimension::Type)jarg2;
39916   {
39917     try {
39918       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39919     } catch (std::out_of_range& e) {
39920       {
39921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39922       };
39923     } catch (std::exception& e) {
39924       {
39925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39926       };
39927     } catch (Dali::DaliException e) {
39928       {
39929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39930       };
39931     } catch (...) {
39932       {
39933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39934       };
39935     }
39936   }
39937
39938   jresult = result;
39939   return jresult;
39940 }
39941
39942
39943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39944   unsigned int jresult ;
39945   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39946   bool result;
39947
39948   arg1 = (Dali::CustomActorImpl *)jarg1;
39949   {
39950     try {
39951       result = (bool)(arg1)->RelayoutDependentOnChildren();
39952     } catch (std::out_of_range& e) {
39953       {
39954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39955       };
39956     } catch (std::exception& e) {
39957       {
39958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39959       };
39960     } catch (Dali::DaliException e) {
39961       {
39962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39963       };
39964     } catch (...) {
39965       {
39966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39967       };
39968     }
39969   }
39970
39971   jresult = result;
39972   return jresult;
39973 }
39974
39975
39976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39977   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39978   Dali::Dimension::Type arg2 ;
39979
39980   arg1 = (Dali::CustomActorImpl *)jarg1;
39981   arg2 = (Dali::Dimension::Type)jarg2;
39982   {
39983     try {
39984       (arg1)->OnCalculateRelayoutSize(arg2);
39985     } catch (std::out_of_range& e) {
39986       {
39987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39988       };
39989     } catch (std::exception& e) {
39990       {
39991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39992       };
39993     } catch (Dali::DaliException e) {
39994       {
39995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39996       };
39997     } catch (...) {
39998       {
39999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40000       };
40001     }
40002   }
40003
40004 }
40005
40006
40007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
40008   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40009   float arg2 ;
40010   Dali::Dimension::Type arg3 ;
40011
40012   arg1 = (Dali::CustomActorImpl *)jarg1;
40013   arg2 = (float)jarg2;
40014   arg3 = (Dali::Dimension::Type)jarg3;
40015   {
40016     try {
40017       (arg1)->OnLayoutNegotiated(arg2,arg3);
40018     } catch (std::out_of_range& e) {
40019       {
40020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40021       };
40022     } catch (std::exception& e) {
40023       {
40024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40025       };
40026     } catch (Dali::DaliException e) {
40027       {
40028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40029       };
40030     } catch (...) {
40031       {
40032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40033       };
40034     }
40035   }
40036
40037 }
40038
40039
40040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
40041   unsigned int jresult ;
40042   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40043   bool result;
40044
40045   arg1 = (Dali::CustomActorImpl *)jarg1;
40046   {
40047     try {
40048       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
40049     } catch (std::out_of_range& e) {
40050       {
40051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40052       };
40053     } catch (std::exception& e) {
40054       {
40055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40056       };
40057     } catch (Dali::DaliException e) {
40058       {
40059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40060       };
40061     } catch (...) {
40062       {
40063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40064       };
40065     }
40066   }
40067
40068   jresult = result;
40069   return jresult;
40070 }
40071
40072
40073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40074   unsigned int jresult ;
40075   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40076   bool result;
40077
40078   arg1 = (Dali::CustomActorImpl *)jarg1;
40079   {
40080     try {
40081       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40082     } catch (std::out_of_range& e) {
40083       {
40084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40085       };
40086     } catch (std::exception& e) {
40087       {
40088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40089       };
40090     } catch (Dali::DaliException e) {
40091       {
40092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40093       };
40094     } catch (...) {
40095       {
40096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40097       };
40098     }
40099   }
40100
40101   jresult = result;
40102   return jresult;
40103 }
40104
40105
40106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40107   unsigned int jresult ;
40108   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40109   bool result;
40110
40111   arg1 = (Dali::CustomActorImpl *)jarg1;
40112   {
40113     try {
40114       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40115     } catch (std::out_of_range& e) {
40116       {
40117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40118       };
40119     } catch (std::exception& e) {
40120       {
40121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40122       };
40123     } catch (Dali::DaliException e) {
40124       {
40125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40126       };
40127     } catch (...) {
40128       {
40129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40130       };
40131     }
40132   }
40133
40134   jresult = result;
40135   return jresult;
40136 }
40137
40138
40139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40140   unsigned int jresult ;
40141   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40142   bool result;
40143
40144   arg1 = (Dali::CustomActorImpl *)jarg1;
40145   {
40146     try {
40147       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40148     } catch (std::out_of_range& e) {
40149       {
40150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40151       };
40152     } catch (std::exception& e) {
40153       {
40154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40155       };
40156     } catch (Dali::DaliException e) {
40157       {
40158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40159       };
40160     } catch (...) {
40161       {
40162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40163       };
40164     }
40165   }
40166
40167   jresult = result;
40168   return jresult;
40169 }
40170
40171
40172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40173   void * jresult ;
40174   Dali::CustomActor *result = 0 ;
40175
40176   {
40177     try {
40178       result = (Dali::CustomActor *)new Dali::CustomActor();
40179     } catch (std::out_of_range& e) {
40180       {
40181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40182       };
40183     } catch (std::exception& e) {
40184       {
40185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40186       };
40187     } catch (Dali::DaliException e) {
40188       {
40189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40190       };
40191     } catch (...) {
40192       {
40193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40194       };
40195     }
40196   }
40197
40198   jresult = (void *)result;
40199   return jresult;
40200 }
40201
40202
40203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40204   void * jresult ;
40205   Dali::BaseHandle arg1 ;
40206   Dali::BaseHandle *argp1 ;
40207   Dali::CustomActor result;
40208
40209   argp1 = (Dali::BaseHandle *)jarg1;
40210   if (!argp1) {
40211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40212     return 0;
40213   }
40214   arg1 = *argp1;
40215   {
40216     try {
40217       result = Dali::CustomActor::DownCast(arg1);
40218     } catch (std::out_of_range& e) {
40219       {
40220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40221       };
40222     } catch (std::exception& e) {
40223       {
40224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40225       };
40226     } catch (Dali::DaliException e) {
40227       {
40228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40229       };
40230     } catch (...) {
40231       {
40232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40233       };
40234     }
40235   }
40236
40237   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40238   return jresult;
40239 }
40240
40241
40242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40243   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40244
40245   arg1 = (Dali::CustomActor *)jarg1;
40246   {
40247     try {
40248       delete arg1;
40249     } catch (std::out_of_range& e) {
40250       {
40251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40252       };
40253     } catch (std::exception& e) {
40254       {
40255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40256       };
40257     } catch (Dali::DaliException e) {
40258       {
40259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40260       };
40261     } catch (...) {
40262       {
40263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40264       };
40265     }
40266   }
40267
40268 }
40269
40270
40271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40272   void * jresult ;
40273   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40274   Dali::CustomActorImpl *result = 0 ;
40275
40276   arg1 = (Dali::CustomActor *)jarg1;
40277   {
40278     try {
40279       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40280     } catch (std::out_of_range& e) {
40281       {
40282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40283       };
40284     } catch (std::exception& e) {
40285       {
40286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40287       };
40288     } catch (Dali::DaliException e) {
40289       {
40290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40291       };
40292     } catch (...) {
40293       {
40294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40295       };
40296     }
40297   }
40298
40299   jresult = (void *)result;
40300   return jresult;
40301 }
40302
40303
40304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40305   void * jresult ;
40306   Dali::CustomActorImpl *arg1 = 0 ;
40307   Dali::CustomActor *result = 0 ;
40308
40309   arg1 = (Dali::CustomActorImpl *)jarg1;
40310   if (!arg1) {
40311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40312     return 0;
40313   }
40314   {
40315     try {
40316       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40317     } catch (std::out_of_range& e) {
40318       {
40319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40320       };
40321     } catch (std::exception& e) {
40322       {
40323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40324       };
40325     } catch (Dali::DaliException e) {
40326       {
40327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40328       };
40329     } catch (...) {
40330       {
40331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40332       };
40333     }
40334   }
40335
40336   jresult = (void *)result;
40337   return jresult;
40338 }
40339
40340
40341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40342   void * jresult ;
40343   Dali::CustomActor *arg1 = 0 ;
40344   Dali::CustomActor *result = 0 ;
40345
40346   arg1 = (Dali::CustomActor *)jarg1;
40347   if (!arg1) {
40348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40349     return 0;
40350   }
40351   {
40352     try {
40353       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40354     } catch (std::out_of_range& e) {
40355       {
40356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40357       };
40358     } catch (std::exception& e) {
40359       {
40360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40361       };
40362     } catch (Dali::DaliException e) {
40363       {
40364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40365       };
40366     } catch (...) {
40367       {
40368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40369       };
40370     }
40371   }
40372
40373   jresult = (void *)result;
40374   return jresult;
40375 }
40376
40377
40378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40379   void * jresult ;
40380   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40381   Dali::CustomActor *arg2 = 0 ;
40382   Dali::CustomActor *result = 0 ;
40383
40384   arg1 = (Dali::CustomActor *)jarg1;
40385   arg2 = (Dali::CustomActor *)jarg2;
40386   if (!arg2) {
40387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40388     return 0;
40389   }
40390   {
40391     try {
40392       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40393     } catch (std::out_of_range& e) {
40394       {
40395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40396       };
40397     } catch (std::exception& e) {
40398       {
40399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40400       };
40401     } catch (Dali::DaliException e) {
40402       {
40403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40404       };
40405     } catch (...) {
40406       {
40407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40408       };
40409     }
40410   }
40411
40412   jresult = (void *)result;
40413   return jresult;
40414 }
40415
40416
40417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40418   int jresult ;
40419   int result;
40420
40421   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40422   jresult = (int)result;
40423   return jresult;
40424 }
40425
40426
40427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40428   int jresult ;
40429   int result;
40430
40431   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40432   jresult = (int)result;
40433   return jresult;
40434 }
40435
40436
40437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40438   int jresult ;
40439   int result;
40440
40441   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40442   jresult = (int)result;
40443   return jresult;
40444 }
40445
40446
40447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40448   int jresult ;
40449   int result;
40450
40451   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40452   jresult = (int)result;
40453   return jresult;
40454 }
40455
40456
40457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40458   int jresult ;
40459   int result;
40460
40461   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40462   jresult = (int)result;
40463   return jresult;
40464 }
40465
40466
40467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40468   int jresult ;
40469   int result;
40470
40471   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40472   jresult = (int)result;
40473   return jresult;
40474 }
40475
40476
40477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40478   int jresult ;
40479   int result;
40480
40481   result = (int)Dali::PanGestureDetector::Property::PANNING;
40482   jresult = (int)result;
40483   return jresult;
40484 }
40485
40486
40487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40488   void * jresult ;
40489   Dali::PanGestureDetector::Property *result = 0 ;
40490
40491   {
40492     try {
40493       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40494     } catch (std::out_of_range& e) {
40495       {
40496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40497       };
40498     } catch (std::exception& e) {
40499       {
40500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40501       };
40502     } catch (Dali::DaliException e) {
40503       {
40504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40505       };
40506     } catch (...) {
40507       {
40508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40509       };
40510     }
40511   }
40512
40513   jresult = (void *)result;
40514   return jresult;
40515 }
40516
40517
40518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40519   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40520
40521   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40522   {
40523     try {
40524       delete arg1;
40525     } catch (std::out_of_range& e) {
40526       {
40527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40528       };
40529     } catch (std::exception& e) {
40530       {
40531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40532       };
40533     } catch (Dali::DaliException e) {
40534       {
40535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40536       };
40537     } catch (...) {
40538       {
40539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40540       };
40541     }
40542   }
40543
40544 }
40545
40546
40547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40548   void * jresult ;
40549   Dali::Radian *result = 0 ;
40550
40551   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40552   jresult = (void *)result;
40553   return jresult;
40554 }
40555
40556
40557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40558   void * jresult ;
40559   Dali::Radian *result = 0 ;
40560
40561   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40562   jresult = (void *)result;
40563   return jresult;
40564 }
40565
40566
40567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40568   void * jresult ;
40569   Dali::Radian *result = 0 ;
40570
40571   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40572   jresult = (void *)result;
40573   return jresult;
40574 }
40575
40576
40577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40578   void * jresult ;
40579   Dali::Radian *result = 0 ;
40580
40581   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40582   jresult = (void *)result;
40583   return jresult;
40584 }
40585
40586
40587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40588   void * jresult ;
40589   Dali::Radian *result = 0 ;
40590
40591   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40592   jresult = (void *)result;
40593   return jresult;
40594 }
40595
40596
40597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40598   void * jresult ;
40599   Dali::Radian *result = 0 ;
40600
40601   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40602   jresult = (void *)result;
40603   return jresult;
40604 }
40605
40606
40607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40608   void * jresult ;
40609   Dali::Radian *result = 0 ;
40610
40611   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40612   jresult = (void *)result;
40613   return jresult;
40614 }
40615
40616
40617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40618   void * jresult ;
40619   Dali::PanGestureDetector *result = 0 ;
40620
40621   {
40622     try {
40623       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40624     } catch (std::out_of_range& e) {
40625       {
40626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40627       };
40628     } catch (std::exception& e) {
40629       {
40630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40631       };
40632     } catch (Dali::DaliException e) {
40633       {
40634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40635       };
40636     } catch (...) {
40637       {
40638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40639       };
40640     }
40641   }
40642
40643   jresult = (void *)result;
40644   return jresult;
40645 }
40646
40647
40648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40649   void * jresult ;
40650   Dali::PanGestureDetector result;
40651
40652   {
40653     try {
40654       result = Dali::PanGestureDetector::New();
40655     } catch (std::out_of_range& e) {
40656       {
40657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40658       };
40659     } catch (std::exception& e) {
40660       {
40661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40662       };
40663     } catch (Dali::DaliException e) {
40664       {
40665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40666       };
40667     } catch (...) {
40668       {
40669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40670       };
40671     }
40672   }
40673
40674   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40675   return jresult;
40676 }
40677
40678
40679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40680   void * jresult ;
40681   Dali::BaseHandle arg1 ;
40682   Dali::BaseHandle *argp1 ;
40683   Dali::PanGestureDetector result;
40684
40685   argp1 = (Dali::BaseHandle *)jarg1;
40686   if (!argp1) {
40687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40688     return 0;
40689   }
40690   arg1 = *argp1;
40691   {
40692     try {
40693       result = Dali::PanGestureDetector::DownCast(arg1);
40694     } catch (std::out_of_range& e) {
40695       {
40696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40697       };
40698     } catch (std::exception& e) {
40699       {
40700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40701       };
40702     } catch (Dali::DaliException e) {
40703       {
40704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40705       };
40706     } catch (...) {
40707       {
40708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40709       };
40710     }
40711   }
40712
40713   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40714   return jresult;
40715 }
40716
40717
40718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40719   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40720
40721   arg1 = (Dali::PanGestureDetector *)jarg1;
40722   {
40723     try {
40724       delete arg1;
40725     } catch (std::out_of_range& e) {
40726       {
40727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40728       };
40729     } catch (std::exception& e) {
40730       {
40731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40732       };
40733     } catch (Dali::DaliException e) {
40734       {
40735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40736       };
40737     } catch (...) {
40738       {
40739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40740       };
40741     }
40742   }
40743
40744 }
40745
40746
40747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40748   void * jresult ;
40749   Dali::PanGestureDetector *arg1 = 0 ;
40750   Dali::PanGestureDetector *result = 0 ;
40751
40752   arg1 = (Dali::PanGestureDetector *)jarg1;
40753   if (!arg1) {
40754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40755     return 0;
40756   }
40757   {
40758     try {
40759       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40760     } catch (std::out_of_range& e) {
40761       {
40762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40763       };
40764     } catch (std::exception& e) {
40765       {
40766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40767       };
40768     } catch (Dali::DaliException e) {
40769       {
40770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40771       };
40772     } catch (...) {
40773       {
40774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40775       };
40776     }
40777   }
40778
40779   jresult = (void *)result;
40780   return jresult;
40781 }
40782
40783
40784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40785   void * jresult ;
40786   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40787   Dali::PanGestureDetector *arg2 = 0 ;
40788   Dali::PanGestureDetector *result = 0 ;
40789
40790   arg1 = (Dali::PanGestureDetector *)jarg1;
40791   arg2 = (Dali::PanGestureDetector *)jarg2;
40792   if (!arg2) {
40793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40794     return 0;
40795   }
40796   {
40797     try {
40798       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40799     } catch (std::out_of_range& e) {
40800       {
40801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40802       };
40803     } catch (std::exception& e) {
40804       {
40805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40806       };
40807     } catch (Dali::DaliException e) {
40808       {
40809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40810       };
40811     } catch (...) {
40812       {
40813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40814       };
40815     }
40816   }
40817
40818   jresult = (void *)result;
40819   return jresult;
40820 }
40821
40822
40823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40824   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40825   unsigned int arg2 ;
40826
40827   arg1 = (Dali::PanGestureDetector *)jarg1;
40828   arg2 = (unsigned int)jarg2;
40829   {
40830     try {
40831       (arg1)->SetMinimumTouchesRequired(arg2);
40832     } catch (std::out_of_range& e) {
40833       {
40834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40835       };
40836     } catch (std::exception& e) {
40837       {
40838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40839       };
40840     } catch (Dali::DaliException e) {
40841       {
40842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40843       };
40844     } catch (...) {
40845       {
40846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40847       };
40848     }
40849   }
40850
40851 }
40852
40853
40854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40855   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40856   unsigned int arg2 ;
40857
40858   arg1 = (Dali::PanGestureDetector *)jarg1;
40859   arg2 = (unsigned int)jarg2;
40860   {
40861     try {
40862       (arg1)->SetMaximumTouchesRequired(arg2);
40863     } catch (std::out_of_range& e) {
40864       {
40865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40866       };
40867     } catch (std::exception& e) {
40868       {
40869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40870       };
40871     } catch (Dali::DaliException e) {
40872       {
40873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40874       };
40875     } catch (...) {
40876       {
40877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40878       };
40879     }
40880   }
40881
40882 }
40883
40884
40885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40886   unsigned int jresult ;
40887   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40888   unsigned int result;
40889
40890   arg1 = (Dali::PanGestureDetector *)jarg1;
40891   {
40892     try {
40893       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40894     } catch (std::out_of_range& e) {
40895       {
40896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40897       };
40898     } catch (std::exception& e) {
40899       {
40900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40901       };
40902     } catch (Dali::DaliException e) {
40903       {
40904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40905       };
40906     } catch (...) {
40907       {
40908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40909       };
40910     }
40911   }
40912
40913   jresult = result;
40914   return jresult;
40915 }
40916
40917
40918 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40919   unsigned int jresult ;
40920   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40921   unsigned int result;
40922
40923   arg1 = (Dali::PanGestureDetector *)jarg1;
40924   {
40925     try {
40926       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40927     } catch (std::out_of_range& e) {
40928       {
40929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40930       };
40931     } catch (std::exception& e) {
40932       {
40933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40934       };
40935     } catch (Dali::DaliException e) {
40936       {
40937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40938       };
40939     } catch (...) {
40940       {
40941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40942       };
40943     }
40944   }
40945
40946   jresult = result;
40947   return jresult;
40948 }
40949
40950
40951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40952   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40953   Dali::Radian arg2 ;
40954   Dali::Radian arg3 ;
40955   Dali::Radian *argp2 ;
40956   Dali::Radian *argp3 ;
40957
40958   arg1 = (Dali::PanGestureDetector *)jarg1;
40959   argp2 = (Dali::Radian *)jarg2;
40960   if (!argp2) {
40961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40962     return ;
40963   }
40964   arg2 = *argp2;
40965   argp3 = (Dali::Radian *)jarg3;
40966   if (!argp3) {
40967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40968     return ;
40969   }
40970   arg3 = *argp3;
40971   {
40972     try {
40973       (arg1)->AddAngle(arg2,arg3);
40974     } catch (std::out_of_range& e) {
40975       {
40976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40977       };
40978     } catch (std::exception& e) {
40979       {
40980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40981       };
40982     } catch (Dali::DaliException e) {
40983       {
40984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40985       };
40986     } catch (...) {
40987       {
40988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40989       };
40990     }
40991   }
40992
40993 }
40994
40995
40996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40997   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40998   Dali::Radian arg2 ;
40999   Dali::Radian *argp2 ;
41000
41001   arg1 = (Dali::PanGestureDetector *)jarg1;
41002   argp2 = (Dali::Radian *)jarg2;
41003   if (!argp2) {
41004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41005     return ;
41006   }
41007   arg2 = *argp2;
41008   {
41009     try {
41010       (arg1)->AddAngle(arg2);
41011     } catch (std::out_of_range& e) {
41012       {
41013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41014       };
41015     } catch (std::exception& e) {
41016       {
41017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41018       };
41019     } catch (Dali::DaliException e) {
41020       {
41021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41022       };
41023     } catch (...) {
41024       {
41025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41026       };
41027     }
41028   }
41029
41030 }
41031
41032
41033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41034   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41035   Dali::Radian arg2 ;
41036   Dali::Radian arg3 ;
41037   Dali::Radian *argp2 ;
41038   Dali::Radian *argp3 ;
41039
41040   arg1 = (Dali::PanGestureDetector *)jarg1;
41041   argp2 = (Dali::Radian *)jarg2;
41042   if (!argp2) {
41043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41044     return ;
41045   }
41046   arg2 = *argp2;
41047   argp3 = (Dali::Radian *)jarg3;
41048   if (!argp3) {
41049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41050     return ;
41051   }
41052   arg3 = *argp3;
41053   {
41054     try {
41055       (arg1)->AddDirection(arg2,arg3);
41056     } catch (std::out_of_range& e) {
41057       {
41058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41059       };
41060     } catch (std::exception& e) {
41061       {
41062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41063       };
41064     } catch (Dali::DaliException e) {
41065       {
41066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41067       };
41068     } catch (...) {
41069       {
41070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41071       };
41072     }
41073   }
41074
41075 }
41076
41077
41078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41079   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41080   Dali::Radian arg2 ;
41081   Dali::Radian *argp2 ;
41082
41083   arg1 = (Dali::PanGestureDetector *)jarg1;
41084   argp2 = (Dali::Radian *)jarg2;
41085   if (!argp2) {
41086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41087     return ;
41088   }
41089   arg2 = *argp2;
41090   {
41091     try {
41092       (arg1)->AddDirection(arg2);
41093     } catch (std::out_of_range& e) {
41094       {
41095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41096       };
41097     } catch (std::exception& e) {
41098       {
41099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41100       };
41101     } catch (Dali::DaliException e) {
41102       {
41103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41104       };
41105     } catch (...) {
41106       {
41107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41108       };
41109     }
41110   }
41111
41112 }
41113
41114
41115 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41116   unsigned long jresult ;
41117   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41118   size_t result;
41119
41120   arg1 = (Dali::PanGestureDetector *)jarg1;
41121   {
41122     try {
41123       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41124     } catch (std::out_of_range& e) {
41125       {
41126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41127       };
41128     } catch (std::exception& e) {
41129       {
41130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41131       };
41132     } catch (Dali::DaliException e) {
41133       {
41134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41135       };
41136     } catch (...) {
41137       {
41138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41139       };
41140     }
41141   }
41142
41143   jresult = (unsigned long)result;
41144   return jresult;
41145 }
41146
41147
41148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41149   void * jresult ;
41150   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41151   size_t arg2 ;
41152   Dali::PanGestureDetector::AngleThresholdPair result;
41153
41154   arg1 = (Dali::PanGestureDetector *)jarg1;
41155   arg2 = (size_t)jarg2;
41156   {
41157     try {
41158       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41159     } catch (std::out_of_range& e) {
41160       {
41161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41162       };
41163     } catch (std::exception& e) {
41164       {
41165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41166       };
41167     } catch (Dali::DaliException e) {
41168       {
41169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41170       };
41171     } catch (...) {
41172       {
41173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41174       };
41175     }
41176   }
41177
41178   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41179   return jresult;
41180 }
41181
41182
41183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41184   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41185
41186   arg1 = (Dali::PanGestureDetector *)jarg1;
41187   {
41188     try {
41189       (arg1)->ClearAngles();
41190     } catch (std::out_of_range& e) {
41191       {
41192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41193       };
41194     } catch (std::exception& e) {
41195       {
41196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41197       };
41198     } catch (Dali::DaliException e) {
41199       {
41200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41201       };
41202     } catch (...) {
41203       {
41204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41205       };
41206     }
41207   }
41208
41209 }
41210
41211
41212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41213   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41214   Dali::Radian arg2 ;
41215   Dali::Radian *argp2 ;
41216
41217   arg1 = (Dali::PanGestureDetector *)jarg1;
41218   argp2 = (Dali::Radian *)jarg2;
41219   if (!argp2) {
41220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41221     return ;
41222   }
41223   arg2 = *argp2;
41224   {
41225     try {
41226       (arg1)->RemoveAngle(arg2);
41227     } catch (std::out_of_range& e) {
41228       {
41229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41230       };
41231     } catch (std::exception& e) {
41232       {
41233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41234       };
41235     } catch (Dali::DaliException e) {
41236       {
41237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41238       };
41239     } catch (...) {
41240       {
41241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41242       };
41243     }
41244   }
41245
41246 }
41247
41248
41249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41250   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41251   Dali::Radian arg2 ;
41252   Dali::Radian *argp2 ;
41253
41254   arg1 = (Dali::PanGestureDetector *)jarg1;
41255   argp2 = (Dali::Radian *)jarg2;
41256   if (!argp2) {
41257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41258     return ;
41259   }
41260   arg2 = *argp2;
41261   {
41262     try {
41263       (arg1)->RemoveDirection(arg2);
41264     } catch (std::out_of_range& e) {
41265       {
41266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41267       };
41268     } catch (std::exception& e) {
41269       {
41270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41271       };
41272     } catch (Dali::DaliException e) {
41273       {
41274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41275       };
41276     } catch (...) {
41277       {
41278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41279       };
41280     }
41281   }
41282
41283 }
41284
41285
41286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41287   void * jresult ;
41288   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41289   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41290
41291   arg1 = (Dali::PanGestureDetector *)jarg1;
41292   {
41293     try {
41294       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41295     } catch (std::out_of_range& e) {
41296       {
41297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41298       };
41299     } catch (std::exception& e) {
41300       {
41301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41302       };
41303     } catch (Dali::DaliException e) {
41304       {
41305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41306       };
41307     } catch (...) {
41308       {
41309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41310       };
41311     }
41312   }
41313
41314   jresult = (void *)result;
41315   return jresult;
41316 }
41317
41318
41319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41320   Dali::PanGesture *arg1 = 0 ;
41321
41322   arg1 = (Dali::PanGesture *)jarg1;
41323   if (!arg1) {
41324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41325     return ;
41326   }
41327   {
41328     try {
41329       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41330     } catch (std::out_of_range& e) {
41331       {
41332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41333       };
41334     } catch (std::exception& e) {
41335       {
41336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41337       };
41338     } catch (Dali::DaliException e) {
41339       {
41340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41341       };
41342     } catch (...) {
41343       {
41344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41345       };
41346     }
41347   }
41348
41349 }
41350
41351
41352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41353   void * jresult ;
41354   Dali::PanGesture *result = 0 ;
41355
41356   {
41357     try {
41358       result = (Dali::PanGesture *)new Dali::PanGesture();
41359     } catch (std::out_of_range& e) {
41360       {
41361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41362       };
41363     } catch (std::exception& e) {
41364       {
41365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41366       };
41367     } catch (Dali::DaliException e) {
41368       {
41369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41370       };
41371     } catch (...) {
41372       {
41373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41374       };
41375     }
41376   }
41377
41378   jresult = (void *)result;
41379   return jresult;
41380 }
41381
41382
41383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41384   void * jresult ;
41385   Dali::Gesture::State arg1 ;
41386   Dali::PanGesture *result = 0 ;
41387
41388   arg1 = (Dali::Gesture::State)jarg1;
41389   {
41390     try {
41391       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41392     } catch (std::out_of_range& e) {
41393       {
41394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41395       };
41396     } catch (std::exception& e) {
41397       {
41398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41399       };
41400     } catch (Dali::DaliException e) {
41401       {
41402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41403       };
41404     } catch (...) {
41405       {
41406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41407       };
41408     }
41409   }
41410
41411   jresult = (void *)result;
41412   return jresult;
41413 }
41414
41415
41416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41417   void * jresult ;
41418   Dali::PanGesture *arg1 = 0 ;
41419   Dali::PanGesture *result = 0 ;
41420
41421   arg1 = (Dali::PanGesture *)jarg1;
41422   if (!arg1) {
41423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41424     return 0;
41425   }
41426   {
41427     try {
41428       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41429     } catch (std::out_of_range& e) {
41430       {
41431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41432       };
41433     } catch (std::exception& e) {
41434       {
41435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41436       };
41437     } catch (Dali::DaliException e) {
41438       {
41439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41440       };
41441     } catch (...) {
41442       {
41443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41444       };
41445     }
41446   }
41447
41448   jresult = (void *)result;
41449   return jresult;
41450 }
41451
41452
41453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41454   void * jresult ;
41455   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41456   Dali::PanGesture *arg2 = 0 ;
41457   Dali::PanGesture *result = 0 ;
41458
41459   arg1 = (Dali::PanGesture *)jarg1;
41460   arg2 = (Dali::PanGesture *)jarg2;
41461   if (!arg2) {
41462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41463     return 0;
41464   }
41465   {
41466     try {
41467       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41468     } catch (std::out_of_range& e) {
41469       {
41470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41471       };
41472     } catch (std::exception& e) {
41473       {
41474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41475       };
41476     } catch (Dali::DaliException e) {
41477       {
41478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41479       };
41480     } catch (...) {
41481       {
41482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41483       };
41484     }
41485   }
41486
41487   jresult = (void *)result;
41488   return jresult;
41489 }
41490
41491
41492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41493   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41494
41495   arg1 = (Dali::PanGesture *)jarg1;
41496   {
41497     try {
41498       delete arg1;
41499     } catch (std::out_of_range& e) {
41500       {
41501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41502       };
41503     } catch (std::exception& e) {
41504       {
41505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41506       };
41507     } catch (Dali::DaliException e) {
41508       {
41509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41510       };
41511     } catch (...) {
41512       {
41513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41514       };
41515     }
41516   }
41517
41518 }
41519
41520
41521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41522   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41523   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41524
41525   arg1 = (Dali::PanGesture *)jarg1;
41526   arg2 = (Dali::Vector2 *)jarg2;
41527   if (arg1) (arg1)->velocity = *arg2;
41528 }
41529
41530
41531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41532   void * jresult ;
41533   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41534   Dali::Vector2 *result = 0 ;
41535
41536   arg1 = (Dali::PanGesture *)jarg1;
41537   result = (Dali::Vector2 *)& ((arg1)->velocity);
41538   jresult = (void *)result;
41539   return jresult;
41540 }
41541
41542
41543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41544   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41545   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41546
41547   arg1 = (Dali::PanGesture *)jarg1;
41548   arg2 = (Dali::Vector2 *)jarg2;
41549   if (arg1) (arg1)->displacement = *arg2;
41550 }
41551
41552
41553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41554   void * jresult ;
41555   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41556   Dali::Vector2 *result = 0 ;
41557
41558   arg1 = (Dali::PanGesture *)jarg1;
41559   result = (Dali::Vector2 *)& ((arg1)->displacement);
41560   jresult = (void *)result;
41561   return jresult;
41562 }
41563
41564
41565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41566   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41567   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41568
41569   arg1 = (Dali::PanGesture *)jarg1;
41570   arg2 = (Dali::Vector2 *)jarg2;
41571   if (arg1) (arg1)->position = *arg2;
41572 }
41573
41574
41575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41576   void * jresult ;
41577   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41578   Dali::Vector2 *result = 0 ;
41579
41580   arg1 = (Dali::PanGesture *)jarg1;
41581   result = (Dali::Vector2 *)& ((arg1)->position);
41582   jresult = (void *)result;
41583   return jresult;
41584 }
41585
41586
41587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41588   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41589   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41590
41591   arg1 = (Dali::PanGesture *)jarg1;
41592   arg2 = (Dali::Vector2 *)jarg2;
41593   if (arg1) (arg1)->screenVelocity = *arg2;
41594 }
41595
41596
41597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41598   void * jresult ;
41599   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41600   Dali::Vector2 *result = 0 ;
41601
41602   arg1 = (Dali::PanGesture *)jarg1;
41603   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41604   jresult = (void *)result;
41605   return jresult;
41606 }
41607
41608
41609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41610   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41611   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41612
41613   arg1 = (Dali::PanGesture *)jarg1;
41614   arg2 = (Dali::Vector2 *)jarg2;
41615   if (arg1) (arg1)->screenDisplacement = *arg2;
41616 }
41617
41618
41619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41620   void * jresult ;
41621   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41622   Dali::Vector2 *result = 0 ;
41623
41624   arg1 = (Dali::PanGesture *)jarg1;
41625   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41626   jresult = (void *)result;
41627   return jresult;
41628 }
41629
41630
41631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41632   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41633   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41634
41635   arg1 = (Dali::PanGesture *)jarg1;
41636   arg2 = (Dali::Vector2 *)jarg2;
41637   if (arg1) (arg1)->screenPosition = *arg2;
41638 }
41639
41640
41641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41642   void * jresult ;
41643   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41644   Dali::Vector2 *result = 0 ;
41645
41646   arg1 = (Dali::PanGesture *)jarg1;
41647   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41648   jresult = (void *)result;
41649   return jresult;
41650 }
41651
41652
41653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41654   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41655   unsigned int arg2 ;
41656
41657   arg1 = (Dali::PanGesture *)jarg1;
41658   arg2 = (unsigned int)jarg2;
41659   if (arg1) (arg1)->numberOfTouches = arg2;
41660 }
41661
41662
41663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41664   unsigned int jresult ;
41665   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41666   unsigned int result;
41667
41668   arg1 = (Dali::PanGesture *)jarg1;
41669   result = (unsigned int) ((arg1)->numberOfTouches);
41670   jresult = result;
41671   return jresult;
41672 }
41673
41674
41675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41676   float jresult ;
41677   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41678   float result;
41679
41680   arg1 = (Dali::PanGesture *)jarg1;
41681   {
41682     try {
41683       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41684     } catch (std::out_of_range& e) {
41685       {
41686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41687       };
41688     } catch (std::exception& e) {
41689       {
41690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41691       };
41692     } catch (Dali::DaliException e) {
41693       {
41694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41695       };
41696     } catch (...) {
41697       {
41698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41699       };
41700     }
41701   }
41702
41703   jresult = result;
41704   return jresult;
41705 }
41706
41707
41708 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41709   float jresult ;
41710   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41711   float result;
41712
41713   arg1 = (Dali::PanGesture *)jarg1;
41714   {
41715     try {
41716       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41717     } catch (std::out_of_range& e) {
41718       {
41719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41720       };
41721     } catch (std::exception& e) {
41722       {
41723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41724       };
41725     } catch (Dali::DaliException e) {
41726       {
41727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41728       };
41729     } catch (...) {
41730       {
41731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41732       };
41733     }
41734   }
41735
41736   jresult = result;
41737   return jresult;
41738 }
41739
41740
41741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41742   float jresult ;
41743   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41744   float result;
41745
41746   arg1 = (Dali::PanGesture *)jarg1;
41747   {
41748     try {
41749       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41750     } catch (std::out_of_range& e) {
41751       {
41752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41753       };
41754     } catch (std::exception& e) {
41755       {
41756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41757       };
41758     } catch (Dali::DaliException e) {
41759       {
41760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41761       };
41762     } catch (...) {
41763       {
41764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41765       };
41766     }
41767   }
41768
41769   jresult = result;
41770   return jresult;
41771 }
41772
41773
41774 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41775   float jresult ;
41776   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41777   float result;
41778
41779   arg1 = (Dali::PanGesture *)jarg1;
41780   {
41781     try {
41782       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41783     } catch (std::out_of_range& e) {
41784       {
41785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41786       };
41787     } catch (std::exception& e) {
41788       {
41789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41790       };
41791     } catch (Dali::DaliException e) {
41792       {
41793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41794       };
41795     } catch (...) {
41796       {
41797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41798       };
41799     }
41800   }
41801
41802   jresult = result;
41803   return jresult;
41804 }
41805
41806
41807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41808   void * jresult ;
41809   Dali::PinchGestureDetector *result = 0 ;
41810
41811   {
41812     try {
41813       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41814     } catch (std::out_of_range& e) {
41815       {
41816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41817       };
41818     } catch (std::exception& e) {
41819       {
41820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41821       };
41822     } catch (Dali::DaliException e) {
41823       {
41824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41825       };
41826     } catch (...) {
41827       {
41828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41829       };
41830     }
41831   }
41832
41833   jresult = (void *)result;
41834   return jresult;
41835 }
41836
41837
41838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41839   void * jresult ;
41840   Dali::PinchGestureDetector result;
41841
41842   {
41843     try {
41844       result = Dali::PinchGestureDetector::New();
41845     } catch (std::out_of_range& e) {
41846       {
41847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41848       };
41849     } catch (std::exception& e) {
41850       {
41851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41852       };
41853     } catch (Dali::DaliException e) {
41854       {
41855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41856       };
41857     } catch (...) {
41858       {
41859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41860       };
41861     }
41862   }
41863
41864   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41865   return jresult;
41866 }
41867
41868
41869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41870   void * jresult ;
41871   Dali::BaseHandle arg1 ;
41872   Dali::BaseHandle *argp1 ;
41873   Dali::PinchGestureDetector result;
41874
41875   argp1 = (Dali::BaseHandle *)jarg1;
41876   if (!argp1) {
41877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41878     return 0;
41879   }
41880   arg1 = *argp1;
41881   {
41882     try {
41883       result = Dali::PinchGestureDetector::DownCast(arg1);
41884     } catch (std::out_of_range& e) {
41885       {
41886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41887       };
41888     } catch (std::exception& e) {
41889       {
41890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41891       };
41892     } catch (Dali::DaliException e) {
41893       {
41894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41895       };
41896     } catch (...) {
41897       {
41898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41899       };
41900     }
41901   }
41902
41903   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41904   return jresult;
41905 }
41906
41907
41908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41909   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41910
41911   arg1 = (Dali::PinchGestureDetector *)jarg1;
41912   {
41913     try {
41914       delete arg1;
41915     } catch (std::out_of_range& e) {
41916       {
41917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41918       };
41919     } catch (std::exception& e) {
41920       {
41921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41922       };
41923     } catch (Dali::DaliException e) {
41924       {
41925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41926       };
41927     } catch (...) {
41928       {
41929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41930       };
41931     }
41932   }
41933
41934 }
41935
41936
41937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41938   void * jresult ;
41939   Dali::PinchGestureDetector *arg1 = 0 ;
41940   Dali::PinchGestureDetector *result = 0 ;
41941
41942   arg1 = (Dali::PinchGestureDetector *)jarg1;
41943   if (!arg1) {
41944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41945     return 0;
41946   }
41947   {
41948     try {
41949       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41950     } catch (std::out_of_range& e) {
41951       {
41952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41953       };
41954     } catch (std::exception& e) {
41955       {
41956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41957       };
41958     } catch (Dali::DaliException e) {
41959       {
41960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41961       };
41962     } catch (...) {
41963       {
41964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41965       };
41966     }
41967   }
41968
41969   jresult = (void *)result;
41970   return jresult;
41971 }
41972
41973
41974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41975   void * jresult ;
41976   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41977   Dali::PinchGestureDetector *arg2 = 0 ;
41978   Dali::PinchGestureDetector *result = 0 ;
41979
41980   arg1 = (Dali::PinchGestureDetector *)jarg1;
41981   arg2 = (Dali::PinchGestureDetector *)jarg2;
41982   if (!arg2) {
41983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41984     return 0;
41985   }
41986   {
41987     try {
41988       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41989     } catch (std::out_of_range& e) {
41990       {
41991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41992       };
41993     } catch (std::exception& e) {
41994       {
41995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41996       };
41997     } catch (Dali::DaliException e) {
41998       {
41999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42000       };
42001     } catch (...) {
42002       {
42003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42004       };
42005     }
42006   }
42007
42008   jresult = (void *)result;
42009   return jresult;
42010 }
42011
42012
42013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
42014   void * jresult ;
42015   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42016   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
42017
42018   arg1 = (Dali::PinchGestureDetector *)jarg1;
42019   {
42020     try {
42021       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42022     } catch (std::out_of_range& e) {
42023       {
42024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42025       };
42026     } catch (std::exception& e) {
42027       {
42028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42029       };
42030     } catch (Dali::DaliException e) {
42031       {
42032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42033       };
42034     } catch (...) {
42035       {
42036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42037       };
42038     }
42039   }
42040
42041   jresult = (void *)result;
42042   return jresult;
42043 }
42044
42045
42046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
42047   void * jresult ;
42048   Dali::Gesture::State arg1 ;
42049   Dali::PinchGesture *result = 0 ;
42050
42051   arg1 = (Dali::Gesture::State)jarg1;
42052   {
42053     try {
42054       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
42055     } catch (std::out_of_range& e) {
42056       {
42057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42058       };
42059     } catch (std::exception& e) {
42060       {
42061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42062       };
42063     } catch (Dali::DaliException e) {
42064       {
42065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42066       };
42067     } catch (...) {
42068       {
42069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42070       };
42071     }
42072   }
42073
42074   jresult = (void *)result;
42075   return jresult;
42076 }
42077
42078
42079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42080   void * jresult ;
42081   Dali::PinchGesture *arg1 = 0 ;
42082   Dali::PinchGesture *result = 0 ;
42083
42084   arg1 = (Dali::PinchGesture *)jarg1;
42085   if (!arg1) {
42086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42087     return 0;
42088   }
42089   {
42090     try {
42091       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42092     } catch (std::out_of_range& e) {
42093       {
42094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42095       };
42096     } catch (std::exception& e) {
42097       {
42098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42099       };
42100     } catch (Dali::DaliException e) {
42101       {
42102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42103       };
42104     } catch (...) {
42105       {
42106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42107       };
42108     }
42109   }
42110
42111   jresult = (void *)result;
42112   return jresult;
42113 }
42114
42115
42116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42117   void * jresult ;
42118   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42119   Dali::PinchGesture *arg2 = 0 ;
42120   Dali::PinchGesture *result = 0 ;
42121
42122   arg1 = (Dali::PinchGesture *)jarg1;
42123   arg2 = (Dali::PinchGesture *)jarg2;
42124   if (!arg2) {
42125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42126     return 0;
42127   }
42128   {
42129     try {
42130       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42131     } catch (std::out_of_range& e) {
42132       {
42133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42134       };
42135     } catch (std::exception& e) {
42136       {
42137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42138       };
42139     } catch (Dali::DaliException e) {
42140       {
42141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42142       };
42143     } catch (...) {
42144       {
42145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42146       };
42147     }
42148   }
42149
42150   jresult = (void *)result;
42151   return jresult;
42152 }
42153
42154
42155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42156   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42157
42158   arg1 = (Dali::PinchGesture *)jarg1;
42159   {
42160     try {
42161       delete arg1;
42162     } catch (std::out_of_range& e) {
42163       {
42164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42165       };
42166     } catch (std::exception& e) {
42167       {
42168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42169       };
42170     } catch (Dali::DaliException e) {
42171       {
42172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42173       };
42174     } catch (...) {
42175       {
42176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42177       };
42178     }
42179   }
42180
42181 }
42182
42183
42184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42185   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42186   float arg2 ;
42187
42188   arg1 = (Dali::PinchGesture *)jarg1;
42189   arg2 = (float)jarg2;
42190   if (arg1) (arg1)->scale = arg2;
42191 }
42192
42193
42194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42195   float jresult ;
42196   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42197   float result;
42198
42199   arg1 = (Dali::PinchGesture *)jarg1;
42200   result = (float) ((arg1)->scale);
42201   jresult = result;
42202   return jresult;
42203 }
42204
42205
42206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42207   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42208   float arg2 ;
42209
42210   arg1 = (Dali::PinchGesture *)jarg1;
42211   arg2 = (float)jarg2;
42212   if (arg1) (arg1)->speed = arg2;
42213 }
42214
42215
42216 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42217   float jresult ;
42218   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42219   float result;
42220
42221   arg1 = (Dali::PinchGesture *)jarg1;
42222   result = (float) ((arg1)->speed);
42223   jresult = result;
42224   return jresult;
42225 }
42226
42227
42228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42229   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42230   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42231
42232   arg1 = (Dali::PinchGesture *)jarg1;
42233   arg2 = (Dali::Vector2 *)jarg2;
42234   if (arg1) (arg1)->screenCenterPoint = *arg2;
42235 }
42236
42237
42238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42239   void * jresult ;
42240   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42241   Dali::Vector2 *result = 0 ;
42242
42243   arg1 = (Dali::PinchGesture *)jarg1;
42244   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42245   jresult = (void *)result;
42246   return jresult;
42247 }
42248
42249
42250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42251   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42252   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42253
42254   arg1 = (Dali::PinchGesture *)jarg1;
42255   arg2 = (Dali::Vector2 *)jarg2;
42256   if (arg1) (arg1)->localCenterPoint = *arg2;
42257 }
42258
42259
42260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42261   void * jresult ;
42262   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42263   Dali::Vector2 *result = 0 ;
42264
42265   arg1 = (Dali::PinchGesture *)jarg1;
42266   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42267   jresult = (void *)result;
42268   return jresult;
42269 }
42270
42271
42272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42273   void * jresult ;
42274   Dali::TapGestureDetector *result = 0 ;
42275
42276   {
42277     try {
42278       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42279     } catch (std::out_of_range& e) {
42280       {
42281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42282       };
42283     } catch (std::exception& e) {
42284       {
42285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42286       };
42287     } catch (Dali::DaliException e) {
42288       {
42289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42290       };
42291     } catch (...) {
42292       {
42293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42294       };
42295     }
42296   }
42297
42298   jresult = (void *)result;
42299   return jresult;
42300 }
42301
42302
42303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42304   void * jresult ;
42305   Dali::TapGestureDetector result;
42306
42307   {
42308     try {
42309       result = Dali::TapGestureDetector::New();
42310     } catch (std::out_of_range& e) {
42311       {
42312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42313       };
42314     } catch (std::exception& e) {
42315       {
42316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42317       };
42318     } catch (Dali::DaliException e) {
42319       {
42320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42321       };
42322     } catch (...) {
42323       {
42324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42325       };
42326     }
42327   }
42328
42329   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42330   return jresult;
42331 }
42332
42333
42334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42335   void * jresult ;
42336   unsigned int arg1 ;
42337   Dali::TapGestureDetector result;
42338
42339   arg1 = (unsigned int)jarg1;
42340   {
42341     try {
42342       result = Dali::TapGestureDetector::New(arg1);
42343     } catch (std::out_of_range& e) {
42344       {
42345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42346       };
42347     } catch (std::exception& e) {
42348       {
42349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42350       };
42351     } catch (Dali::DaliException e) {
42352       {
42353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42354       };
42355     } catch (...) {
42356       {
42357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42358       };
42359     }
42360   }
42361
42362   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42363   return jresult;
42364 }
42365
42366
42367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42368   void * jresult ;
42369   Dali::BaseHandle arg1 ;
42370   Dali::BaseHandle *argp1 ;
42371   Dali::TapGestureDetector result;
42372
42373   argp1 = (Dali::BaseHandle *)jarg1;
42374   if (!argp1) {
42375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42376     return 0;
42377   }
42378   arg1 = *argp1;
42379   {
42380     try {
42381       result = Dali::TapGestureDetector::DownCast(arg1);
42382     } catch (std::out_of_range& e) {
42383       {
42384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42385       };
42386     } catch (std::exception& e) {
42387       {
42388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42389       };
42390     } catch (Dali::DaliException e) {
42391       {
42392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42393       };
42394     } catch (...) {
42395       {
42396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42397       };
42398     }
42399   }
42400
42401   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42402   return jresult;
42403 }
42404
42405
42406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42407   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42408
42409   arg1 = (Dali::TapGestureDetector *)jarg1;
42410   {
42411     try {
42412       delete arg1;
42413     } catch (std::out_of_range& e) {
42414       {
42415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42416       };
42417     } catch (std::exception& e) {
42418       {
42419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42420       };
42421     } catch (Dali::DaliException e) {
42422       {
42423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42424       };
42425     } catch (...) {
42426       {
42427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42428       };
42429     }
42430   }
42431
42432 }
42433
42434
42435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42436   void * jresult ;
42437   Dali::TapGestureDetector *arg1 = 0 ;
42438   Dali::TapGestureDetector *result = 0 ;
42439
42440   arg1 = (Dali::TapGestureDetector *)jarg1;
42441   if (!arg1) {
42442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42443     return 0;
42444   }
42445   {
42446     try {
42447       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42448     } catch (std::out_of_range& e) {
42449       {
42450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42451       };
42452     } catch (std::exception& e) {
42453       {
42454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42455       };
42456     } catch (Dali::DaliException e) {
42457       {
42458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42459       };
42460     } catch (...) {
42461       {
42462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42463       };
42464     }
42465   }
42466
42467   jresult = (void *)result;
42468   return jresult;
42469 }
42470
42471
42472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42473   void * jresult ;
42474   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42475   Dali::TapGestureDetector *arg2 = 0 ;
42476   Dali::TapGestureDetector *result = 0 ;
42477
42478   arg1 = (Dali::TapGestureDetector *)jarg1;
42479   arg2 = (Dali::TapGestureDetector *)jarg2;
42480   if (!arg2) {
42481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42482     return 0;
42483   }
42484   {
42485     try {
42486       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42487     } catch (std::out_of_range& e) {
42488       {
42489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42490       };
42491     } catch (std::exception& e) {
42492       {
42493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42494       };
42495     } catch (Dali::DaliException e) {
42496       {
42497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42498       };
42499     } catch (...) {
42500       {
42501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42502       };
42503     }
42504   }
42505
42506   jresult = (void *)result;
42507   return jresult;
42508 }
42509
42510
42511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42512   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42513   unsigned int arg2 ;
42514
42515   arg1 = (Dali::TapGestureDetector *)jarg1;
42516   arg2 = (unsigned int)jarg2;
42517   {
42518     try {
42519       (arg1)->SetMinimumTapsRequired(arg2);
42520     } catch (std::out_of_range& e) {
42521       {
42522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42523       };
42524     } catch (std::exception& e) {
42525       {
42526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42527       };
42528     } catch (Dali::DaliException e) {
42529       {
42530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42531       };
42532     } catch (...) {
42533       {
42534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42535       };
42536     }
42537   }
42538
42539 }
42540
42541
42542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42543   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42544   unsigned int arg2 ;
42545
42546   arg1 = (Dali::TapGestureDetector *)jarg1;
42547   arg2 = (unsigned int)jarg2;
42548   {
42549     try {
42550       (arg1)->SetMaximumTapsRequired(arg2);
42551     } catch (std::out_of_range& e) {
42552       {
42553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42554       };
42555     } catch (std::exception& e) {
42556       {
42557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42558       };
42559     } catch (Dali::DaliException e) {
42560       {
42561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42562       };
42563     } catch (...) {
42564       {
42565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42566       };
42567     }
42568   }
42569
42570 }
42571
42572
42573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42574   unsigned int jresult ;
42575   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42576   unsigned int result;
42577
42578   arg1 = (Dali::TapGestureDetector *)jarg1;
42579   {
42580     try {
42581       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42582     } catch (std::out_of_range& e) {
42583       {
42584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42585       };
42586     } catch (std::exception& e) {
42587       {
42588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42589       };
42590     } catch (Dali::DaliException e) {
42591       {
42592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42593       };
42594     } catch (...) {
42595       {
42596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42597       };
42598     }
42599   }
42600
42601   jresult = result;
42602   return jresult;
42603 }
42604
42605
42606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42607   unsigned int jresult ;
42608   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42609   unsigned int result;
42610
42611   arg1 = (Dali::TapGestureDetector *)jarg1;
42612   {
42613     try {
42614       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42615     } catch (std::out_of_range& e) {
42616       {
42617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42618       };
42619     } catch (std::exception& e) {
42620       {
42621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42622       };
42623     } catch (Dali::DaliException e) {
42624       {
42625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42626       };
42627     } catch (...) {
42628       {
42629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42630       };
42631     }
42632   }
42633
42634   jresult = result;
42635   return jresult;
42636 }
42637
42638
42639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42640   void * jresult ;
42641   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42642   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42643
42644   arg1 = (Dali::TapGestureDetector *)jarg1;
42645   {
42646     try {
42647       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42648     } catch (std::out_of_range& e) {
42649       {
42650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42651       };
42652     } catch (std::exception& e) {
42653       {
42654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42655       };
42656     } catch (Dali::DaliException e) {
42657       {
42658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42659       };
42660     } catch (...) {
42661       {
42662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42663       };
42664     }
42665   }
42666
42667   jresult = (void *)result;
42668   return jresult;
42669 }
42670
42671
42672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42673   void * jresult ;
42674   Dali::TapGesture *result = 0 ;
42675
42676   {
42677     try {
42678       result = (Dali::TapGesture *)new Dali::TapGesture();
42679     } catch (std::out_of_range& e) {
42680       {
42681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42682       };
42683     } catch (std::exception& e) {
42684       {
42685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42686       };
42687     } catch (Dali::DaliException e) {
42688       {
42689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42690       };
42691     } catch (...) {
42692       {
42693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42694       };
42695     }
42696   }
42697
42698   jresult = (void *)result;
42699   return jresult;
42700 }
42701
42702
42703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42704   void * jresult ;
42705   Dali::TapGesture *arg1 = 0 ;
42706   Dali::TapGesture *result = 0 ;
42707
42708   arg1 = (Dali::TapGesture *)jarg1;
42709   if (!arg1) {
42710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42711     return 0;
42712   }
42713   {
42714     try {
42715       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42716     } catch (std::out_of_range& e) {
42717       {
42718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42719       };
42720     } catch (std::exception& e) {
42721       {
42722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42723       };
42724     } catch (Dali::DaliException e) {
42725       {
42726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42727       };
42728     } catch (...) {
42729       {
42730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42731       };
42732     }
42733   }
42734
42735   jresult = (void *)result;
42736   return jresult;
42737 }
42738
42739
42740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42741   void * jresult ;
42742   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42743   Dali::TapGesture *arg2 = 0 ;
42744   Dali::TapGesture *result = 0 ;
42745
42746   arg1 = (Dali::TapGesture *)jarg1;
42747   arg2 = (Dali::TapGesture *)jarg2;
42748   if (!arg2) {
42749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42750     return 0;
42751   }
42752   {
42753     try {
42754       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42755     } catch (std::out_of_range& e) {
42756       {
42757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42758       };
42759     } catch (std::exception& e) {
42760       {
42761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42762       };
42763     } catch (Dali::DaliException e) {
42764       {
42765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42766       };
42767     } catch (...) {
42768       {
42769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42770       };
42771     }
42772   }
42773
42774   jresult = (void *)result;
42775   return jresult;
42776 }
42777
42778
42779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42780   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42781
42782   arg1 = (Dali::TapGesture *)jarg1;
42783   {
42784     try {
42785       delete arg1;
42786     } catch (std::out_of_range& e) {
42787       {
42788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42789       };
42790     } catch (std::exception& e) {
42791       {
42792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42793       };
42794     } catch (Dali::DaliException e) {
42795       {
42796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42797       };
42798     } catch (...) {
42799       {
42800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42801       };
42802     }
42803   }
42804
42805 }
42806
42807
42808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42809   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42810   unsigned int arg2 ;
42811
42812   arg1 = (Dali::TapGesture *)jarg1;
42813   arg2 = (unsigned int)jarg2;
42814   if (arg1) (arg1)->numberOfTaps = arg2;
42815 }
42816
42817
42818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42819   unsigned int jresult ;
42820   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42821   unsigned int result;
42822
42823   arg1 = (Dali::TapGesture *)jarg1;
42824   result = (unsigned int) ((arg1)->numberOfTaps);
42825   jresult = result;
42826   return jresult;
42827 }
42828
42829
42830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42831   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42832   unsigned int arg2 ;
42833
42834   arg1 = (Dali::TapGesture *)jarg1;
42835   arg2 = (unsigned int)jarg2;
42836   if (arg1) (arg1)->numberOfTouches = arg2;
42837 }
42838
42839
42840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42841   unsigned int jresult ;
42842   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42843   unsigned int result;
42844
42845   arg1 = (Dali::TapGesture *)jarg1;
42846   result = (unsigned int) ((arg1)->numberOfTouches);
42847   jresult = result;
42848   return jresult;
42849 }
42850
42851
42852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42853   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42854   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42855
42856   arg1 = (Dali::TapGesture *)jarg1;
42857   arg2 = (Dali::Vector2 *)jarg2;
42858   if (arg1) (arg1)->screenPoint = *arg2;
42859 }
42860
42861
42862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42863   void * jresult ;
42864   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42865   Dali::Vector2 *result = 0 ;
42866
42867   arg1 = (Dali::TapGesture *)jarg1;
42868   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42869   jresult = (void *)result;
42870   return jresult;
42871 }
42872
42873
42874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42875   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42876   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42877
42878   arg1 = (Dali::TapGesture *)jarg1;
42879   arg2 = (Dali::Vector2 *)jarg2;
42880   if (arg1) (arg1)->localPoint = *arg2;
42881 }
42882
42883
42884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42885   void * jresult ;
42886   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42887   Dali::Vector2 *result = 0 ;
42888
42889   arg1 = (Dali::TapGesture *)jarg1;
42890   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42891   jresult = (void *)result;
42892   return jresult;
42893 }
42894
42895
42896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42897   void * jresult ;
42898   Dali::AlphaFunction *result = 0 ;
42899
42900   {
42901     try {
42902       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42903     } catch (std::out_of_range& e) {
42904       {
42905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42906       };
42907     } catch (std::exception& e) {
42908       {
42909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42910       };
42911     } catch (Dali::DaliException e) {
42912       {
42913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42914       };
42915     } catch (...) {
42916       {
42917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42918       };
42919     }
42920   }
42921
42922   jresult = (void *)result;
42923   return jresult;
42924 }
42925
42926
42927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42928   void * jresult ;
42929   Dali::AlphaFunction::BuiltinFunction arg1 ;
42930   Dali::AlphaFunction *result = 0 ;
42931
42932   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42933   {
42934     try {
42935       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42936     } catch (std::out_of_range& e) {
42937       {
42938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42939       };
42940     } catch (std::exception& e) {
42941       {
42942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42943       };
42944     } catch (Dali::DaliException e) {
42945       {
42946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42947       };
42948     } catch (...) {
42949       {
42950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42951       };
42952     }
42953   }
42954
42955   jresult = (void *)result;
42956   return jresult;
42957 }
42958
42959
42960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42961   void * jresult ;
42962   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42963   Dali::AlphaFunction *result = 0 ;
42964
42965   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42966   {
42967     try {
42968       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42969     } catch (std::out_of_range& e) {
42970       {
42971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42972       };
42973     } catch (std::exception& e) {
42974       {
42975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42976       };
42977     } catch (Dali::DaliException e) {
42978       {
42979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42980       };
42981     } catch (...) {
42982       {
42983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42984       };
42985     }
42986   }
42987
42988   jresult = (void *)result;
42989   return jresult;
42990 }
42991
42992
42993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42994   void * jresult ;
42995   Dali::Vector2 *arg1 = 0 ;
42996   Dali::Vector2 *arg2 = 0 ;
42997   Dali::AlphaFunction *result = 0 ;
42998
42999   arg1 = (Dali::Vector2 *)jarg1;
43000   if (!arg1) {
43001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43002     return 0;
43003   }
43004   arg2 = (Dali::Vector2 *)jarg2;
43005   if (!arg2) {
43006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43007     return 0;
43008   }
43009   {
43010     try {
43011       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
43012     } catch (std::out_of_range& e) {
43013       {
43014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43015       };
43016     } catch (std::exception& e) {
43017       {
43018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43019       };
43020     } catch (Dali::DaliException e) {
43021       {
43022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43023       };
43024     } catch (...) {
43025       {
43026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43027       };
43028     }
43029   }
43030
43031   jresult = (void *)result;
43032   return jresult;
43033 }
43034
43035
43036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
43037   void * jresult ;
43038   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43039   Dali::Vector4 result;
43040
43041   arg1 = (Dali::AlphaFunction *)jarg1;
43042   {
43043     try {
43044       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
43045     } catch (std::out_of_range& e) {
43046       {
43047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43048       };
43049     } catch (std::exception& e) {
43050       {
43051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43052       };
43053     } catch (Dali::DaliException e) {
43054       {
43055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43056       };
43057     } catch (...) {
43058       {
43059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43060       };
43061     }
43062   }
43063
43064   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43065   return jresult;
43066 }
43067
43068
43069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43070   void * jresult ;
43071   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43072   Dali::AlphaFunctionPrototype result;
43073
43074   arg1 = (Dali::AlphaFunction *)jarg1;
43075   {
43076     try {
43077       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
43078     } catch (std::out_of_range& e) {
43079       {
43080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43081       };
43082     } catch (std::exception& e) {
43083       {
43084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43085       };
43086     } catch (Dali::DaliException e) {
43087       {
43088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43089       };
43090     } catch (...) {
43091       {
43092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43093       };
43094     }
43095   }
43096
43097   jresult = (void *)result;
43098   return jresult;
43099 }
43100
43101
43102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43103   int jresult ;
43104   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43105   Dali::AlphaFunction::BuiltinFunction result;
43106
43107   arg1 = (Dali::AlphaFunction *)jarg1;
43108   {
43109     try {
43110       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43111     } catch (std::out_of_range& e) {
43112       {
43113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43114       };
43115     } catch (std::exception& e) {
43116       {
43117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43118       };
43119     } catch (Dali::DaliException e) {
43120       {
43121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43122       };
43123     } catch (...) {
43124       {
43125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43126       };
43127     }
43128   }
43129
43130   jresult = (int)result;
43131   return jresult;
43132 }
43133
43134
43135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43136   int jresult ;
43137   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43138   Dali::AlphaFunction::Mode result;
43139
43140   arg1 = (Dali::AlphaFunction *)jarg1;
43141   {
43142     try {
43143       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43144     } catch (std::out_of_range& e) {
43145       {
43146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43147       };
43148     } catch (std::exception& e) {
43149       {
43150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43151       };
43152     } catch (Dali::DaliException e) {
43153       {
43154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43155       };
43156     } catch (...) {
43157       {
43158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43159       };
43160     }
43161   }
43162
43163   jresult = (int)result;
43164   return jresult;
43165 }
43166
43167
43168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43169   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43170
43171   arg1 = (Dali::AlphaFunction *)jarg1;
43172   {
43173     try {
43174       delete arg1;
43175     } catch (std::out_of_range& e) {
43176       {
43177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43178       };
43179     } catch (std::exception& e) {
43180       {
43181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43182       };
43183     } catch (Dali::DaliException e) {
43184       {
43185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43186       };
43187     } catch (...) {
43188       {
43189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43190       };
43191     }
43192   }
43193
43194 }
43195
43196
43197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43198   void * jresult ;
43199   Dali::KeyFrames result;
43200
43201   {
43202     try {
43203       result = Dali::KeyFrames::New();
43204     } catch (std::out_of_range& e) {
43205       {
43206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43207       };
43208     } catch (std::exception& e) {
43209       {
43210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43211       };
43212     } catch (Dali::DaliException e) {
43213       {
43214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43215       };
43216     } catch (...) {
43217       {
43218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43219       };
43220     }
43221   }
43222
43223   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43224   return jresult;
43225 }
43226
43227
43228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43229   void * jresult ;
43230   Dali::BaseHandle arg1 ;
43231   Dali::BaseHandle *argp1 ;
43232   Dali::KeyFrames result;
43233
43234   argp1 = (Dali::BaseHandle *)jarg1;
43235   if (!argp1) {
43236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43237     return 0;
43238   }
43239   arg1 = *argp1;
43240   {
43241     try {
43242       result = Dali::KeyFrames::DownCast(arg1);
43243     } catch (std::out_of_range& e) {
43244       {
43245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43246       };
43247     } catch (std::exception& e) {
43248       {
43249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43250       };
43251     } catch (Dali::DaliException e) {
43252       {
43253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43254       };
43255     } catch (...) {
43256       {
43257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43258       };
43259     }
43260   }
43261
43262   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43263   return jresult;
43264 }
43265
43266
43267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43268   void * jresult ;
43269   Dali::KeyFrames *result = 0 ;
43270
43271   {
43272     try {
43273       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43274     } catch (std::out_of_range& e) {
43275       {
43276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43277       };
43278     } catch (std::exception& e) {
43279       {
43280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43281       };
43282     } catch (Dali::DaliException e) {
43283       {
43284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43285       };
43286     } catch (...) {
43287       {
43288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43289       };
43290     }
43291   }
43292
43293   jresult = (void *)result;
43294   return jresult;
43295 }
43296
43297
43298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43299   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43300
43301   arg1 = (Dali::KeyFrames *)jarg1;
43302   {
43303     try {
43304       delete arg1;
43305     } catch (std::out_of_range& e) {
43306       {
43307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43308       };
43309     } catch (std::exception& e) {
43310       {
43311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43312       };
43313     } catch (Dali::DaliException e) {
43314       {
43315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43316       };
43317     } catch (...) {
43318       {
43319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43320       };
43321     }
43322   }
43323
43324 }
43325
43326
43327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43328   void * jresult ;
43329   Dali::KeyFrames *arg1 = 0 ;
43330   Dali::KeyFrames *result = 0 ;
43331
43332   arg1 = (Dali::KeyFrames *)jarg1;
43333   if (!arg1) {
43334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43335     return 0;
43336   }
43337   {
43338     try {
43339       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43340     } catch (std::out_of_range& e) {
43341       {
43342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43343       };
43344     } catch (std::exception& e) {
43345       {
43346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43347       };
43348     } catch (Dali::DaliException e) {
43349       {
43350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43351       };
43352     } catch (...) {
43353       {
43354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43355       };
43356     }
43357   }
43358
43359   jresult = (void *)result;
43360   return jresult;
43361 }
43362
43363
43364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43365   void * jresult ;
43366   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43367   Dali::KeyFrames *arg2 = 0 ;
43368   Dali::KeyFrames *result = 0 ;
43369
43370   arg1 = (Dali::KeyFrames *)jarg1;
43371   arg2 = (Dali::KeyFrames *)jarg2;
43372   if (!arg2) {
43373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43374     return 0;
43375   }
43376   {
43377     try {
43378       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43379     } catch (std::out_of_range& e) {
43380       {
43381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43382       };
43383     } catch (std::exception& e) {
43384       {
43385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43386       };
43387     } catch (Dali::DaliException e) {
43388       {
43389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43390       };
43391     } catch (...) {
43392       {
43393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43394       };
43395     }
43396   }
43397
43398   jresult = (void *)result;
43399   return jresult;
43400 }
43401
43402
43403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43404   int jresult ;
43405   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43406   Dali::Property::Type result;
43407
43408   arg1 = (Dali::KeyFrames *)jarg1;
43409   {
43410     try {
43411       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43412     } catch (std::out_of_range& e) {
43413       {
43414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43415       };
43416     } catch (std::exception& e) {
43417       {
43418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43419       };
43420     } catch (Dali::DaliException e) {
43421       {
43422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43423       };
43424     } catch (...) {
43425       {
43426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43427       };
43428     }
43429   }
43430
43431   jresult = (int)result;
43432   return jresult;
43433 }
43434
43435
43436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43437   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43438   float arg2 ;
43439   Dali::Property::Value arg3 ;
43440   Dali::Property::Value *argp3 ;
43441
43442   arg1 = (Dali::KeyFrames *)jarg1;
43443   arg2 = (float)jarg2;
43444   argp3 = (Dali::Property::Value *)jarg3;
43445   if (!argp3) {
43446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43447     return ;
43448   }
43449   arg3 = *argp3;
43450   {
43451     try {
43452       (arg1)->Add(arg2,arg3);
43453     } catch (std::out_of_range& e) {
43454       {
43455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43456       };
43457     } catch (std::exception& e) {
43458       {
43459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43460       };
43461     } catch (Dali::DaliException e) {
43462       {
43463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43464       };
43465     } catch (...) {
43466       {
43467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43468       };
43469     }
43470   }
43471
43472 }
43473
43474
43475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43476   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43477   float arg2 ;
43478   Dali::Property::Value arg3 ;
43479   Dali::AlphaFunction arg4 ;
43480   Dali::Property::Value *argp3 ;
43481   Dali::AlphaFunction *argp4 ;
43482
43483   arg1 = (Dali::KeyFrames *)jarg1;
43484   arg2 = (float)jarg2;
43485   argp3 = (Dali::Property::Value *)jarg3;
43486   if (!argp3) {
43487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43488     return ;
43489   }
43490   arg3 = *argp3;
43491   argp4 = (Dali::AlphaFunction *)jarg4;
43492   if (!argp4) {
43493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43494     return ;
43495   }
43496   arg4 = *argp4;
43497   {
43498     try {
43499       (arg1)->Add(arg2,arg3,arg4);
43500     } catch (std::out_of_range& e) {
43501       {
43502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43503       };
43504     } catch (std::exception& e) {
43505       {
43506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43507       };
43508     } catch (Dali::DaliException e) {
43509       {
43510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43511       };
43512     } catch (...) {
43513       {
43514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43515       };
43516     }
43517   }
43518
43519 }
43520
43521
43522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43523   int jresult ;
43524   int result;
43525
43526   result = (int)Dali::Path::Property::POINTS;
43527   jresult = (int)result;
43528   return jresult;
43529 }
43530
43531
43532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43533   int jresult ;
43534   int result;
43535
43536   result = (int)Dali::Path::Property::CONTROL_POINTS;
43537   jresult = (int)result;
43538   return jresult;
43539 }
43540
43541
43542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43543   void * jresult ;
43544   Dali::Path::Property *result = 0 ;
43545
43546   {
43547     try {
43548       result = (Dali::Path::Property *)new Dali::Path::Property();
43549     } catch (std::out_of_range& e) {
43550       {
43551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43552       };
43553     } catch (std::exception& e) {
43554       {
43555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43556       };
43557     } catch (Dali::DaliException e) {
43558       {
43559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43560       };
43561     } catch (...) {
43562       {
43563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43564       };
43565     }
43566   }
43567
43568   jresult = (void *)result;
43569   return jresult;
43570 }
43571
43572
43573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43574   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43575
43576   arg1 = (Dali::Path::Property *)jarg1;
43577   {
43578     try {
43579       delete arg1;
43580     } catch (std::out_of_range& e) {
43581       {
43582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43583       };
43584     } catch (std::exception& e) {
43585       {
43586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43587       };
43588     } catch (Dali::DaliException e) {
43589       {
43590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43591       };
43592     } catch (...) {
43593       {
43594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43595       };
43596     }
43597   }
43598
43599 }
43600
43601
43602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43603   void * jresult ;
43604   Dali::Path result;
43605
43606   {
43607     try {
43608       result = Dali::Path::New();
43609     } catch (std::out_of_range& e) {
43610       {
43611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43612       };
43613     } catch (std::exception& e) {
43614       {
43615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43616       };
43617     } catch (Dali::DaliException e) {
43618       {
43619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43620       };
43621     } catch (...) {
43622       {
43623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43624       };
43625     }
43626   }
43627
43628   jresult = new Dali::Path((const Dali::Path &)result);
43629   return jresult;
43630 }
43631
43632
43633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43634   void * jresult ;
43635   Dali::BaseHandle arg1 ;
43636   Dali::BaseHandle *argp1 ;
43637   Dali::Path result;
43638
43639   argp1 = (Dali::BaseHandle *)jarg1;
43640   if (!argp1) {
43641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43642     return 0;
43643   }
43644   arg1 = *argp1;
43645   {
43646     try {
43647       result = Dali::Path::DownCast(arg1);
43648     } catch (std::out_of_range& e) {
43649       {
43650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43651       };
43652     } catch (std::exception& e) {
43653       {
43654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43655       };
43656     } catch (Dali::DaliException e) {
43657       {
43658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43659       };
43660     } catch (...) {
43661       {
43662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43663       };
43664     }
43665   }
43666
43667   jresult = new Dali::Path((const Dali::Path &)result);
43668   return jresult;
43669 }
43670
43671
43672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43673   void * jresult ;
43674   Dali::Path *result = 0 ;
43675
43676   {
43677     try {
43678       result = (Dali::Path *)new Dali::Path();
43679     } catch (std::out_of_range& e) {
43680       {
43681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43682       };
43683     } catch (std::exception& e) {
43684       {
43685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43686       };
43687     } catch (Dali::DaliException e) {
43688       {
43689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43690       };
43691     } catch (...) {
43692       {
43693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43694       };
43695     }
43696   }
43697
43698   jresult = (void *)result;
43699   return jresult;
43700 }
43701
43702
43703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43704   Dali::Path *arg1 = (Dali::Path *) 0 ;
43705
43706   arg1 = (Dali::Path *)jarg1;
43707   {
43708     try {
43709       delete arg1;
43710     } catch (std::out_of_range& e) {
43711       {
43712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43713       };
43714     } catch (std::exception& e) {
43715       {
43716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43717       };
43718     } catch (Dali::DaliException e) {
43719       {
43720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43721       };
43722     } catch (...) {
43723       {
43724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43725       };
43726     }
43727   }
43728
43729 }
43730
43731
43732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43733   void * jresult ;
43734   Dali::Path *arg1 = 0 ;
43735   Dali::Path *result = 0 ;
43736
43737   arg1 = (Dali::Path *)jarg1;
43738   if (!arg1) {
43739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43740     return 0;
43741   }
43742   {
43743     try {
43744       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43745     } catch (std::out_of_range& e) {
43746       {
43747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43748       };
43749     } catch (std::exception& e) {
43750       {
43751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43752       };
43753     } catch (Dali::DaliException e) {
43754       {
43755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43756       };
43757     } catch (...) {
43758       {
43759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43760       };
43761     }
43762   }
43763
43764   jresult = (void *)result;
43765   return jresult;
43766 }
43767
43768
43769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43770   void * jresult ;
43771   Dali::Path *arg1 = (Dali::Path *) 0 ;
43772   Dali::Path *arg2 = 0 ;
43773   Dali::Path *result = 0 ;
43774
43775   arg1 = (Dali::Path *)jarg1;
43776   arg2 = (Dali::Path *)jarg2;
43777   if (!arg2) {
43778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43779     return 0;
43780   }
43781   {
43782     try {
43783       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43784     } catch (std::out_of_range& e) {
43785       {
43786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43787       };
43788     } catch (std::exception& e) {
43789       {
43790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43791       };
43792     } catch (Dali::DaliException e) {
43793       {
43794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43795       };
43796     } catch (...) {
43797       {
43798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43799       };
43800     }
43801   }
43802
43803   jresult = (void *)result;
43804   return jresult;
43805 }
43806
43807
43808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43809   Dali::Path *arg1 = (Dali::Path *) 0 ;
43810   Dali::Vector3 *arg2 = 0 ;
43811
43812   arg1 = (Dali::Path *)jarg1;
43813   arg2 = (Dali::Vector3 *)jarg2;
43814   if (!arg2) {
43815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43816     return ;
43817   }
43818   {
43819     try {
43820       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43821     } catch (std::out_of_range& e) {
43822       {
43823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43824       };
43825     } catch (std::exception& e) {
43826       {
43827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43828       };
43829     } catch (Dali::DaliException e) {
43830       {
43831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43832       };
43833     } catch (...) {
43834       {
43835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43836       };
43837     }
43838   }
43839
43840 }
43841
43842
43843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43844   Dali::Path *arg1 = (Dali::Path *) 0 ;
43845   Dali::Vector3 *arg2 = 0 ;
43846
43847   arg1 = (Dali::Path *)jarg1;
43848   arg2 = (Dali::Vector3 *)jarg2;
43849   if (!arg2) {
43850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43851     return ;
43852   }
43853   {
43854     try {
43855       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43856     } catch (std::out_of_range& e) {
43857       {
43858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43859       };
43860     } catch (std::exception& e) {
43861       {
43862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43863       };
43864     } catch (Dali::DaliException e) {
43865       {
43866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43867       };
43868     } catch (...) {
43869       {
43870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43871       };
43872     }
43873   }
43874
43875 }
43876
43877
43878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43879   Dali::Path *arg1 = (Dali::Path *) 0 ;
43880   float arg2 ;
43881
43882   arg1 = (Dali::Path *)jarg1;
43883   arg2 = (float)jarg2;
43884   {
43885     try {
43886       (arg1)->GenerateControlPoints(arg2);
43887     } catch (std::out_of_range& e) {
43888       {
43889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43890       };
43891     } catch (std::exception& e) {
43892       {
43893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43894       };
43895     } catch (Dali::DaliException e) {
43896       {
43897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43898       };
43899     } catch (...) {
43900       {
43901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43902       };
43903     }
43904   }
43905
43906 }
43907
43908
43909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43910   Dali::Path *arg1 = (Dali::Path *) 0 ;
43911   float arg2 ;
43912   Dali::Vector3 *arg3 = 0 ;
43913   Dali::Vector3 *arg4 = 0 ;
43914
43915   arg1 = (Dali::Path *)jarg1;
43916   arg2 = (float)jarg2;
43917   arg3 = (Dali::Vector3 *)jarg3;
43918   if (!arg3) {
43919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43920     return ;
43921   }
43922   arg4 = (Dali::Vector3 *)jarg4;
43923   if (!arg4) {
43924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43925     return ;
43926   }
43927   {
43928     try {
43929       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43930     } catch (std::out_of_range& e) {
43931       {
43932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43933       };
43934     } catch (std::exception& e) {
43935       {
43936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43937       };
43938     } catch (Dali::DaliException e) {
43939       {
43940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43941       };
43942     } catch (...) {
43943       {
43944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43945       };
43946     }
43947   }
43948
43949 }
43950
43951
43952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43953   void * jresult ;
43954   Dali::Path *arg1 = (Dali::Path *) 0 ;
43955   size_t arg2 ;
43956   Dali::Vector3 *result = 0 ;
43957
43958   arg1 = (Dali::Path *)jarg1;
43959   arg2 = (size_t)jarg2;
43960   {
43961     try {
43962       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43963     } catch (std::out_of_range& e) {
43964       {
43965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43966       };
43967     } catch (std::exception& e) {
43968       {
43969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43970       };
43971     } catch (Dali::DaliException e) {
43972       {
43973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43974       };
43975     } catch (...) {
43976       {
43977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43978       };
43979     }
43980   }
43981
43982   jresult = (void *)result;
43983   return jresult;
43984 }
43985
43986
43987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43988   void * jresult ;
43989   Dali::Path *arg1 = (Dali::Path *) 0 ;
43990   size_t arg2 ;
43991   Dali::Vector3 *result = 0 ;
43992
43993   arg1 = (Dali::Path *)jarg1;
43994   arg2 = (size_t)jarg2;
43995   {
43996     try {
43997       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43998     } catch (std::out_of_range& e) {
43999       {
44000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44001       };
44002     } catch (std::exception& e) {
44003       {
44004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44005       };
44006     } catch (Dali::DaliException e) {
44007       {
44008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44009       };
44010     } catch (...) {
44011       {
44012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44013       };
44014     }
44015   }
44016
44017   jresult = (void *)result;
44018   return jresult;
44019 }
44020
44021
44022 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
44023   unsigned long jresult ;
44024   Dali::Path *arg1 = (Dali::Path *) 0 ;
44025   size_t result;
44026
44027   arg1 = (Dali::Path *)jarg1;
44028   {
44029     try {
44030       result = ((Dali::Path const *)arg1)->GetPointCount();
44031     } catch (std::out_of_range& e) {
44032       {
44033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44034       };
44035     } catch (std::exception& e) {
44036       {
44037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44038       };
44039     } catch (Dali::DaliException e) {
44040       {
44041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44042       };
44043     } catch (...) {
44044       {
44045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44046       };
44047     }
44048   }
44049
44050   jresult = (unsigned long)result;
44051   return jresult;
44052 }
44053
44054
44055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
44056   void * jresult ;
44057   float arg1 ;
44058   Dali::TimePeriod *result = 0 ;
44059
44060   arg1 = (float)jarg1;
44061   {
44062     try {
44063       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44064     } catch (std::out_of_range& e) {
44065       {
44066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44067       };
44068     } catch (std::exception& e) {
44069       {
44070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44071       };
44072     } catch (Dali::DaliException e) {
44073       {
44074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44075       };
44076     } catch (...) {
44077       {
44078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44079       };
44080     }
44081   }
44082
44083   jresult = (void *)result;
44084   return jresult;
44085 }
44086
44087
44088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44089   void * jresult ;
44090   float arg1 ;
44091   float arg2 ;
44092   Dali::TimePeriod *result = 0 ;
44093
44094   arg1 = (float)jarg1;
44095   arg2 = (float)jarg2;
44096   {
44097     try {
44098       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44099     } catch (std::out_of_range& e) {
44100       {
44101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44102       };
44103     } catch (std::exception& e) {
44104       {
44105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44106       };
44107     } catch (Dali::DaliException e) {
44108       {
44109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44110       };
44111     } catch (...) {
44112       {
44113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44114       };
44115     }
44116   }
44117
44118   jresult = (void *)result;
44119   return jresult;
44120 }
44121
44122
44123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44124   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44125
44126   arg1 = (Dali::TimePeriod *)jarg1;
44127   {
44128     try {
44129       delete arg1;
44130     } catch (std::out_of_range& e) {
44131       {
44132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44133       };
44134     } catch (std::exception& e) {
44135       {
44136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44137       };
44138     } catch (Dali::DaliException e) {
44139       {
44140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44141       };
44142     } catch (...) {
44143       {
44144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44145       };
44146     }
44147   }
44148
44149 }
44150
44151
44152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44153   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44154   float arg2 ;
44155
44156   arg1 = (Dali::TimePeriod *)jarg1;
44157   arg2 = (float)jarg2;
44158   if (arg1) (arg1)->delaySeconds = arg2;
44159 }
44160
44161
44162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44163   float jresult ;
44164   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44165   float result;
44166
44167   arg1 = (Dali::TimePeriod *)jarg1;
44168   result = (float) ((arg1)->delaySeconds);
44169   jresult = result;
44170   return jresult;
44171 }
44172
44173
44174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44175   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44176   float arg2 ;
44177
44178   arg1 = (Dali::TimePeriod *)jarg1;
44179   arg2 = (float)jarg2;
44180   if (arg1) (arg1)->durationSeconds = arg2;
44181 }
44182
44183
44184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44185   float jresult ;
44186   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44187   float result;
44188
44189   arg1 = (Dali::TimePeriod *)jarg1;
44190   result = (float) ((arg1)->durationSeconds);
44191   jresult = result;
44192   return jresult;
44193 }
44194
44195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44196   int jresult ;
44197   int result;
44198
44199   result = (int)Dali::LinearConstrainer::Property::VALUE;
44200   jresult = (int)result;
44201   return jresult;
44202 }
44203
44204
44205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44206   int jresult ;
44207   int result;
44208
44209   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44210   jresult = (int)result;
44211   return jresult;
44212 }
44213
44214
44215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44216   void * jresult ;
44217   Dali::LinearConstrainer::Property *result = 0 ;
44218
44219   {
44220     try {
44221       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44222     } catch (std::out_of_range& e) {
44223       {
44224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44225       };
44226     } catch (std::exception& e) {
44227       {
44228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44229       };
44230     } catch (Dali::DaliException e) {
44231       {
44232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44233       };
44234     } catch (...) {
44235       {
44236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44237       };
44238     }
44239   }
44240
44241   jresult = (void *)result;
44242   return jresult;
44243 }
44244
44245
44246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44247   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44248
44249   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44250   {
44251     try {
44252       delete arg1;
44253     } catch (std::out_of_range& e) {
44254       {
44255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44256       };
44257     } catch (std::exception& e) {
44258       {
44259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44260       };
44261     } catch (Dali::DaliException e) {
44262       {
44263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44264       };
44265     } catch (...) {
44266       {
44267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44268       };
44269     }
44270   }
44271
44272 }
44273
44274
44275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44276   void * jresult ;
44277   Dali::LinearConstrainer result;
44278
44279   {
44280     try {
44281       result = Dali::LinearConstrainer::New();
44282     } catch (std::out_of_range& e) {
44283       {
44284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44285       };
44286     } catch (std::exception& e) {
44287       {
44288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44289       };
44290     } catch (Dali::DaliException e) {
44291       {
44292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44293       };
44294     } catch (...) {
44295       {
44296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44297       };
44298     }
44299   }
44300
44301   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44302   return jresult;
44303 }
44304
44305
44306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44307   void * jresult ;
44308   Dali::BaseHandle arg1 ;
44309   Dali::BaseHandle *argp1 ;
44310   Dali::LinearConstrainer result;
44311
44312   argp1 = (Dali::BaseHandle *)jarg1;
44313   if (!argp1) {
44314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44315     return 0;
44316   }
44317   arg1 = *argp1;
44318   {
44319     try {
44320       result = Dali::LinearConstrainer::DownCast(arg1);
44321     } catch (std::out_of_range& e) {
44322       {
44323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44324       };
44325     } catch (std::exception& e) {
44326       {
44327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44328       };
44329     } catch (Dali::DaliException e) {
44330       {
44331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44332       };
44333     } catch (...) {
44334       {
44335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44336       };
44337     }
44338   }
44339
44340   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44341   return jresult;
44342 }
44343
44344
44345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44346   void * jresult ;
44347   Dali::LinearConstrainer *result = 0 ;
44348
44349   {
44350     try {
44351       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44352     } catch (std::out_of_range& e) {
44353       {
44354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44355       };
44356     } catch (std::exception& e) {
44357       {
44358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44359       };
44360     } catch (Dali::DaliException e) {
44361       {
44362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44363       };
44364     } catch (...) {
44365       {
44366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44367       };
44368     }
44369   }
44370
44371   jresult = (void *)result;
44372   return jresult;
44373 }
44374
44375
44376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44377   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44378
44379   arg1 = (Dali::LinearConstrainer *)jarg1;
44380   {
44381     try {
44382       delete arg1;
44383     } catch (std::out_of_range& e) {
44384       {
44385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44386       };
44387     } catch (std::exception& e) {
44388       {
44389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44390       };
44391     } catch (Dali::DaliException e) {
44392       {
44393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44394       };
44395     } catch (...) {
44396       {
44397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44398       };
44399     }
44400   }
44401
44402 }
44403
44404
44405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44406   void * jresult ;
44407   Dali::LinearConstrainer *arg1 = 0 ;
44408   Dali::LinearConstrainer *result = 0 ;
44409
44410   arg1 = (Dali::LinearConstrainer *)jarg1;
44411   if (!arg1) {
44412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44413     return 0;
44414   }
44415   {
44416     try {
44417       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44418     } catch (std::out_of_range& e) {
44419       {
44420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44421       };
44422     } catch (std::exception& e) {
44423       {
44424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44425       };
44426     } catch (Dali::DaliException e) {
44427       {
44428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44429       };
44430     } catch (...) {
44431       {
44432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44433       };
44434     }
44435   }
44436
44437   jresult = (void *)result;
44438   return jresult;
44439 }
44440
44441
44442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44443   void * jresult ;
44444   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44445   Dali::LinearConstrainer *arg2 = 0 ;
44446   Dali::LinearConstrainer *result = 0 ;
44447
44448   arg1 = (Dali::LinearConstrainer *)jarg1;
44449   arg2 = (Dali::LinearConstrainer *)jarg2;
44450   if (!arg2) {
44451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44452     return 0;
44453   }
44454   {
44455     try {
44456       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44457     } catch (std::out_of_range& e) {
44458       {
44459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44460       };
44461     } catch (std::exception& e) {
44462       {
44463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44464       };
44465     } catch (Dali::DaliException e) {
44466       {
44467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44468       };
44469     } catch (...) {
44470       {
44471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44472       };
44473     }
44474   }
44475
44476   jresult = (void *)result;
44477   return jresult;
44478 }
44479
44480
44481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44482   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44483   SwigValueWrapper< Dali::Property > arg2 ;
44484   SwigValueWrapper< Dali::Property > arg3 ;
44485   Dali::Vector2 *arg4 = 0 ;
44486   Dali::Vector2 *arg5 = 0 ;
44487   Dali::Property *argp2 ;
44488   Dali::Property *argp3 ;
44489
44490   arg1 = (Dali::LinearConstrainer *)jarg1;
44491   argp2 = (Dali::Property *)jarg2;
44492   if (!argp2) {
44493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44494     return ;
44495   }
44496   arg2 = *argp2;
44497   argp3 = (Dali::Property *)jarg3;
44498   if (!argp3) {
44499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44500     return ;
44501   }
44502   arg3 = *argp3;
44503   arg4 = (Dali::Vector2 *)jarg4;
44504   if (!arg4) {
44505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44506     return ;
44507   }
44508   arg5 = (Dali::Vector2 *)jarg5;
44509   if (!arg5) {
44510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44511     return ;
44512   }
44513   {
44514     try {
44515       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44516     } catch (std::out_of_range& e) {
44517       {
44518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44519       };
44520     } catch (std::exception& e) {
44521       {
44522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44523       };
44524     } catch (Dali::DaliException e) {
44525       {
44526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44527       };
44528     } catch (...) {
44529       {
44530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44531       };
44532     }
44533   }
44534
44535 }
44536
44537
44538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44539   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44540   SwigValueWrapper< Dali::Property > arg2 ;
44541   SwigValueWrapper< Dali::Property > arg3 ;
44542   Dali::Vector2 *arg4 = 0 ;
44543   Dali::Property *argp2 ;
44544   Dali::Property *argp3 ;
44545
44546   arg1 = (Dali::LinearConstrainer *)jarg1;
44547   argp2 = (Dali::Property *)jarg2;
44548   if (!argp2) {
44549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44550     return ;
44551   }
44552   arg2 = *argp2;
44553   argp3 = (Dali::Property *)jarg3;
44554   if (!argp3) {
44555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44556     return ;
44557   }
44558   arg3 = *argp3;
44559   arg4 = (Dali::Vector2 *)jarg4;
44560   if (!arg4) {
44561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44562     return ;
44563   }
44564   {
44565     try {
44566       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44567     } catch (std::out_of_range& e) {
44568       {
44569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44570       };
44571     } catch (std::exception& e) {
44572       {
44573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44574       };
44575     } catch (Dali::DaliException e) {
44576       {
44577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44578       };
44579     } catch (...) {
44580       {
44581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44582       };
44583     }
44584   }
44585
44586 }
44587
44588
44589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44590   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44591   Dali::Handle *arg2 = 0 ;
44592
44593   arg1 = (Dali::LinearConstrainer *)jarg1;
44594   arg2 = (Dali::Handle *)jarg2;
44595   if (!arg2) {
44596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44597     return ;
44598   }
44599   {
44600     try {
44601       (arg1)->Remove(*arg2);
44602     } catch (std::out_of_range& e) {
44603       {
44604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44605       };
44606     } catch (std::exception& e) {
44607       {
44608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44609       };
44610     } catch (Dali::DaliException e) {
44611       {
44612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44613       };
44614     } catch (...) {
44615       {
44616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44617       };
44618     }
44619   }
44620
44621 }
44622
44623
44624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44625   int jresult ;
44626   int result;
44627
44628   result = (int)Dali::PathConstrainer::Property::FORWARD;
44629   jresult = (int)result;
44630   return jresult;
44631 }
44632
44633
44634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44635   int jresult ;
44636   int result;
44637
44638   result = (int)Dali::PathConstrainer::Property::POINTS;
44639   jresult = (int)result;
44640   return jresult;
44641 }
44642
44643
44644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44645   int jresult ;
44646   int result;
44647
44648   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44649   jresult = (int)result;
44650   return jresult;
44651 }
44652
44653
44654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44655   void * jresult ;
44656   Dali::PathConstrainer::Property *result = 0 ;
44657
44658   {
44659     try {
44660       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44661     } catch (std::out_of_range& e) {
44662       {
44663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44664       };
44665     } catch (std::exception& e) {
44666       {
44667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44668       };
44669     } catch (Dali::DaliException e) {
44670       {
44671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44672       };
44673     } catch (...) {
44674       {
44675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44676       };
44677     }
44678   }
44679
44680   jresult = (void *)result;
44681   return jresult;
44682 }
44683
44684
44685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44686   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44687
44688   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44689   {
44690     try {
44691       delete arg1;
44692     } catch (std::out_of_range& e) {
44693       {
44694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44695       };
44696     } catch (std::exception& e) {
44697       {
44698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44699       };
44700     } catch (Dali::DaliException e) {
44701       {
44702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44703       };
44704     } catch (...) {
44705       {
44706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44707       };
44708     }
44709   }
44710
44711 }
44712
44713
44714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44715   void * jresult ;
44716   Dali::PathConstrainer result;
44717
44718   {
44719     try {
44720       result = Dali::PathConstrainer::New();
44721     } catch (std::out_of_range& e) {
44722       {
44723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44724       };
44725     } catch (std::exception& e) {
44726       {
44727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44728       };
44729     } catch (Dali::DaliException e) {
44730       {
44731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44732       };
44733     } catch (...) {
44734       {
44735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44736       };
44737     }
44738   }
44739
44740   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44741   return jresult;
44742 }
44743
44744
44745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44746   void * jresult ;
44747   Dali::BaseHandle arg1 ;
44748   Dali::BaseHandle *argp1 ;
44749   Dali::PathConstrainer result;
44750
44751   argp1 = (Dali::BaseHandle *)jarg1;
44752   if (!argp1) {
44753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44754     return 0;
44755   }
44756   arg1 = *argp1;
44757   {
44758     try {
44759       result = Dali::PathConstrainer::DownCast(arg1);
44760     } catch (std::out_of_range& e) {
44761       {
44762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44763       };
44764     } catch (std::exception& e) {
44765       {
44766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44767       };
44768     } catch (Dali::DaliException e) {
44769       {
44770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44771       };
44772     } catch (...) {
44773       {
44774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44775       };
44776     }
44777   }
44778
44779   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44780   return jresult;
44781 }
44782
44783
44784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44785   void * jresult ;
44786   Dali::PathConstrainer *result = 0 ;
44787
44788   {
44789     try {
44790       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44791     } catch (std::out_of_range& e) {
44792       {
44793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44794       };
44795     } catch (std::exception& e) {
44796       {
44797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44798       };
44799     } catch (Dali::DaliException e) {
44800       {
44801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44802       };
44803     } catch (...) {
44804       {
44805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44806       };
44807     }
44808   }
44809
44810   jresult = (void *)result;
44811   return jresult;
44812 }
44813
44814
44815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44816   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44817
44818   arg1 = (Dali::PathConstrainer *)jarg1;
44819   {
44820     try {
44821       delete arg1;
44822     } catch (std::out_of_range& e) {
44823       {
44824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44825       };
44826     } catch (std::exception& e) {
44827       {
44828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44829       };
44830     } catch (Dali::DaliException e) {
44831       {
44832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44833       };
44834     } catch (...) {
44835       {
44836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44837       };
44838     }
44839   }
44840
44841 }
44842
44843
44844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44845   void * jresult ;
44846   Dali::PathConstrainer *arg1 = 0 ;
44847   Dali::PathConstrainer *result = 0 ;
44848
44849   arg1 = (Dali::PathConstrainer *)jarg1;
44850   if (!arg1) {
44851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44852     return 0;
44853   }
44854   {
44855     try {
44856       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44857     } catch (std::out_of_range& e) {
44858       {
44859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44860       };
44861     } catch (std::exception& e) {
44862       {
44863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44864       };
44865     } catch (Dali::DaliException e) {
44866       {
44867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44868       };
44869     } catch (...) {
44870       {
44871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44872       };
44873     }
44874   }
44875
44876   jresult = (void *)result;
44877   return jresult;
44878 }
44879
44880
44881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44882   void * jresult ;
44883   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44884   Dali::PathConstrainer *arg2 = 0 ;
44885   Dali::PathConstrainer *result = 0 ;
44886
44887   arg1 = (Dali::PathConstrainer *)jarg1;
44888   arg2 = (Dali::PathConstrainer *)jarg2;
44889   if (!arg2) {
44890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44891     return 0;
44892   }
44893   {
44894     try {
44895       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44896     } catch (std::out_of_range& e) {
44897       {
44898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44899       };
44900     } catch (std::exception& e) {
44901       {
44902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44903       };
44904     } catch (Dali::DaliException e) {
44905       {
44906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44907       };
44908     } catch (...) {
44909       {
44910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44911       };
44912     }
44913   }
44914
44915   jresult = (void *)result;
44916   return jresult;
44917 }
44918
44919
44920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44921   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44922   SwigValueWrapper< Dali::Property > arg2 ;
44923   SwigValueWrapper< Dali::Property > arg3 ;
44924   Dali::Vector2 *arg4 = 0 ;
44925   Dali::Vector2 *arg5 = 0 ;
44926   Dali::Property *argp2 ;
44927   Dali::Property *argp3 ;
44928
44929   arg1 = (Dali::PathConstrainer *)jarg1;
44930   argp2 = (Dali::Property *)jarg2;
44931   if (!argp2) {
44932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44933     return ;
44934   }
44935   arg2 = *argp2;
44936   argp3 = (Dali::Property *)jarg3;
44937   if (!argp3) {
44938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44939     return ;
44940   }
44941   arg3 = *argp3;
44942   arg4 = (Dali::Vector2 *)jarg4;
44943   if (!arg4) {
44944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44945     return ;
44946   }
44947   arg5 = (Dali::Vector2 *)jarg5;
44948   if (!arg5) {
44949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44950     return ;
44951   }
44952   {
44953     try {
44954       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44955     } catch (std::out_of_range& e) {
44956       {
44957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44958       };
44959     } catch (std::exception& e) {
44960       {
44961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44962       };
44963     } catch (Dali::DaliException e) {
44964       {
44965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44966       };
44967     } catch (...) {
44968       {
44969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44970       };
44971     }
44972   }
44973
44974 }
44975
44976
44977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44978   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44979   SwigValueWrapper< Dali::Property > arg2 ;
44980   SwigValueWrapper< Dali::Property > arg3 ;
44981   Dali::Vector2 *arg4 = 0 ;
44982   Dali::Property *argp2 ;
44983   Dali::Property *argp3 ;
44984
44985   arg1 = (Dali::PathConstrainer *)jarg1;
44986   argp2 = (Dali::Property *)jarg2;
44987   if (!argp2) {
44988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44989     return ;
44990   }
44991   arg2 = *argp2;
44992   argp3 = (Dali::Property *)jarg3;
44993   if (!argp3) {
44994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44995     return ;
44996   }
44997   arg3 = *argp3;
44998   arg4 = (Dali::Vector2 *)jarg4;
44999   if (!arg4) {
45000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45001     return ;
45002   }
45003   {
45004     try {
45005       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
45006     } catch (std::out_of_range& e) {
45007       {
45008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45009       };
45010     } catch (std::exception& e) {
45011       {
45012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45013       };
45014     } catch (Dali::DaliException e) {
45015       {
45016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45017       };
45018     } catch (...) {
45019       {
45020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45021       };
45022     }
45023   }
45024
45025 }
45026
45027
45028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
45029   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45030   Dali::Handle *arg2 = 0 ;
45031
45032   arg1 = (Dali::PathConstrainer *)jarg1;
45033   arg2 = (Dali::Handle *)jarg2;
45034   if (!arg2) {
45035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
45036     return ;
45037   }
45038   {
45039     try {
45040       (arg1)->Remove(*arg2);
45041     } catch (std::out_of_range& e) {
45042       {
45043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45044       };
45045     } catch (std::exception& e) {
45046       {
45047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45048       };
45049     } catch (Dali::DaliException e) {
45050       {
45051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45052       };
45053     } catch (...) {
45054       {
45055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45056       };
45057     }
45058   }
45059
45060 }
45061
45062
45063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45064   int jresult ;
45065   Dali::FittingMode::Type result;
45066
45067   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45068   jresult = (int)result;
45069   return jresult;
45070 }
45071
45072
45073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45074   int jresult ;
45075   Dali::SamplingMode::Type result;
45076
45077   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45078   jresult = (int)result;
45079   return jresult;
45080 }
45081
45082
45083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
45084   void * jresult ;
45085   Dali::BufferImage *result = 0 ;
45086
45087   {
45088     try {
45089       result = (Dali::BufferImage *)new Dali::BufferImage();
45090     } catch (std::out_of_range& e) {
45091       {
45092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45093       };
45094     } catch (std::exception& e) {
45095       {
45096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45097       };
45098     } catch (Dali::DaliException e) {
45099       {
45100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45101       };
45102     } catch (...) {
45103       {
45104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45105       };
45106     }
45107   }
45108
45109   jresult = (void *)result;
45110   return jresult;
45111 }
45112
45113
45114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45115   void * jresult ;
45116   unsigned int arg1 ;
45117   unsigned int arg2 ;
45118   Dali::Pixel::Format arg3 ;
45119   Dali::BufferImage result;
45120
45121   arg1 = (unsigned int)jarg1;
45122   arg2 = (unsigned int)jarg2;
45123   arg3 = (Dali::Pixel::Format)jarg3;
45124   {
45125     try {
45126       result = Dali::BufferImage::New(arg1,arg2,arg3);
45127     } catch (std::out_of_range& e) {
45128       {
45129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45130       };
45131     } catch (std::exception& e) {
45132       {
45133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45134       };
45135     } catch (Dali::DaliException e) {
45136       {
45137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45138       };
45139     } catch (...) {
45140       {
45141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45142       };
45143     }
45144   }
45145
45146   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45147   return jresult;
45148 }
45149
45150
45151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45152   void * jresult ;
45153   unsigned int arg1 ;
45154   unsigned int arg2 ;
45155   Dali::BufferImage result;
45156
45157   arg1 = (unsigned int)jarg1;
45158   arg2 = (unsigned int)jarg2;
45159   {
45160     try {
45161       result = Dali::BufferImage::New(arg1,arg2);
45162     } catch (std::out_of_range& e) {
45163       {
45164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45165       };
45166     } catch (std::exception& e) {
45167       {
45168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45169       };
45170     } catch (Dali::DaliException e) {
45171       {
45172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45173       };
45174     } catch (...) {
45175       {
45176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45177       };
45178     }
45179   }
45180
45181   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45182   return jresult;
45183 }
45184
45185
45186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45187   void * jresult ;
45188   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45189   unsigned int arg2 ;
45190   unsigned int arg3 ;
45191   Dali::Pixel::Format arg4 ;
45192   unsigned int arg5 ;
45193   Dali::BufferImage result;
45194
45195   arg1 = jarg1;
45196   arg2 = (unsigned int)jarg2;
45197   arg3 = (unsigned int)jarg3;
45198   arg4 = (Dali::Pixel::Format)jarg4;
45199   arg5 = (unsigned int)jarg5;
45200   {
45201     try {
45202       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45203     } catch (std::out_of_range& e) {
45204       {
45205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45206       };
45207     } catch (std::exception& e) {
45208       {
45209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45210       };
45211     } catch (Dali::DaliException e) {
45212       {
45213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45214       };
45215     } catch (...) {
45216       {
45217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45218       };
45219     }
45220   }
45221
45222   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45223
45224
45225   return jresult;
45226 }
45227
45228
45229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45230   void * jresult ;
45231   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45232   unsigned int arg2 ;
45233   unsigned int arg3 ;
45234   Dali::Pixel::Format arg4 ;
45235   Dali::BufferImage result;
45236
45237   arg1 = jarg1;
45238   arg2 = (unsigned int)jarg2;
45239   arg3 = (unsigned int)jarg3;
45240   arg4 = (Dali::Pixel::Format)jarg4;
45241   {
45242     try {
45243       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45244     } catch (std::out_of_range& e) {
45245       {
45246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45247       };
45248     } catch (std::exception& e) {
45249       {
45250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45251       };
45252     } catch (Dali::DaliException e) {
45253       {
45254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45255       };
45256     } catch (...) {
45257       {
45258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45259       };
45260     }
45261   }
45262
45263   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45264
45265
45266   return jresult;
45267 }
45268
45269
45270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45271   void * jresult ;
45272   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45273   unsigned int arg2 ;
45274   unsigned int arg3 ;
45275   Dali::BufferImage result;
45276
45277   arg1 = jarg1;
45278   arg2 = (unsigned int)jarg2;
45279   arg3 = (unsigned int)jarg3;
45280   {
45281     try {
45282       result = Dali::BufferImage::New(arg1,arg2,arg3);
45283     } catch (std::out_of_range& e) {
45284       {
45285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45286       };
45287     } catch (std::exception& e) {
45288       {
45289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45290       };
45291     } catch (Dali::DaliException e) {
45292       {
45293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45294       };
45295     } catch (...) {
45296       {
45297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45298       };
45299     }
45300   }
45301
45302   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45303
45304
45305   return jresult;
45306 }
45307
45308
45309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45310   void * jresult ;
45311   Dali::BaseHandle arg1 ;
45312   Dali::BaseHandle *argp1 ;
45313   Dali::BufferImage result;
45314
45315   argp1 = (Dali::BaseHandle *)jarg1;
45316   if (!argp1) {
45317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45318     return 0;
45319   }
45320   arg1 = *argp1;
45321   {
45322     try {
45323       result = Dali::BufferImage::DownCast(arg1);
45324     } catch (std::out_of_range& e) {
45325       {
45326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45327       };
45328     } catch (std::exception& e) {
45329       {
45330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45331       };
45332     } catch (Dali::DaliException e) {
45333       {
45334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45335       };
45336     } catch (...) {
45337       {
45338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45339       };
45340     }
45341   }
45342
45343   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45344   return jresult;
45345 }
45346
45347
45348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45349   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45350
45351   arg1 = (Dali::BufferImage *)jarg1;
45352   {
45353     try {
45354       delete arg1;
45355     } catch (std::out_of_range& e) {
45356       {
45357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45358       };
45359     } catch (std::exception& e) {
45360       {
45361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45362       };
45363     } catch (Dali::DaliException e) {
45364       {
45365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45366       };
45367     } catch (...) {
45368       {
45369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45370       };
45371     }
45372   }
45373
45374 }
45375
45376
45377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45378   void * jresult ;
45379   Dali::BufferImage *arg1 = 0 ;
45380   Dali::BufferImage *result = 0 ;
45381
45382   arg1 = (Dali::BufferImage *)jarg1;
45383   if (!arg1) {
45384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45385     return 0;
45386   }
45387   {
45388     try {
45389       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45390     } catch (std::out_of_range& e) {
45391       {
45392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45393       };
45394     } catch (std::exception& e) {
45395       {
45396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45397       };
45398     } catch (Dali::DaliException e) {
45399       {
45400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45401       };
45402     } catch (...) {
45403       {
45404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45405       };
45406     }
45407   }
45408
45409   jresult = (void *)result;
45410   return jresult;
45411 }
45412
45413
45414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45415   void * jresult ;
45416   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45417   Dali::BufferImage *arg2 = 0 ;
45418   Dali::BufferImage *result = 0 ;
45419
45420   arg1 = (Dali::BufferImage *)jarg1;
45421   arg2 = (Dali::BufferImage *)jarg2;
45422   if (!arg2) {
45423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45424     return 0;
45425   }
45426   {
45427     try {
45428       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45429     } catch (std::out_of_range& e) {
45430       {
45431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45432       };
45433     } catch (std::exception& e) {
45434       {
45435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45436       };
45437     } catch (Dali::DaliException e) {
45438       {
45439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45440       };
45441     } catch (...) {
45442       {
45443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45444       };
45445     }
45446   }
45447
45448   jresult = (void *)result;
45449   return jresult;
45450 }
45451
45452
45453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45454   void * jresult ;
45455   Dali::BufferImage result;
45456
45457   {
45458     try {
45459       result = Dali::BufferImage::WHITE();
45460     } catch (std::out_of_range& e) {
45461       {
45462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45463       };
45464     } catch (std::exception& e) {
45465       {
45466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45467       };
45468     } catch (Dali::DaliException e) {
45469       {
45470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45471       };
45472     } catch (...) {
45473       {
45474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45475       };
45476     }
45477   }
45478
45479   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45480   return jresult;
45481 }
45482
45483
45484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45485   void * jresult ;
45486   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45487   Dali::PixelBuffer *result = 0 ;
45488
45489   arg1 = (Dali::BufferImage *)jarg1;
45490   {
45491     try {
45492       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45493     } catch (std::out_of_range& e) {
45494       {
45495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45496       };
45497     } catch (std::exception& e) {
45498       {
45499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45500       };
45501     } catch (Dali::DaliException e) {
45502       {
45503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45504       };
45505     } catch (...) {
45506       {
45507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45508       };
45509     }
45510   }
45511
45512   jresult = (void *)result;
45513   return jresult;
45514 }
45515
45516
45517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45518   unsigned int jresult ;
45519   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45520   unsigned int result;
45521
45522   arg1 = (Dali::BufferImage *)jarg1;
45523   {
45524     try {
45525       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45526     } catch (std::out_of_range& e) {
45527       {
45528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45529       };
45530     } catch (std::exception& e) {
45531       {
45532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45533       };
45534     } catch (Dali::DaliException e) {
45535       {
45536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45537       };
45538     } catch (...) {
45539       {
45540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45541       };
45542     }
45543   }
45544
45545   jresult = result;
45546   return jresult;
45547 }
45548
45549
45550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45551   unsigned int jresult ;
45552   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45553   unsigned int result;
45554
45555   arg1 = (Dali::BufferImage *)jarg1;
45556   {
45557     try {
45558       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45559     } catch (std::out_of_range& e) {
45560       {
45561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45562       };
45563     } catch (std::exception& e) {
45564       {
45565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45566       };
45567     } catch (Dali::DaliException e) {
45568       {
45569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45570       };
45571     } catch (...) {
45572       {
45573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45574       };
45575     }
45576   }
45577
45578   jresult = result;
45579   return jresult;
45580 }
45581
45582
45583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45584   int jresult ;
45585   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45586   Dali::Pixel::Format result;
45587
45588   arg1 = (Dali::BufferImage *)jarg1;
45589   {
45590     try {
45591       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45592     } catch (std::out_of_range& e) {
45593       {
45594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45595       };
45596     } catch (std::exception& e) {
45597       {
45598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45599       };
45600     } catch (Dali::DaliException e) {
45601       {
45602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45603       };
45604     } catch (...) {
45605       {
45606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45607       };
45608     }
45609   }
45610
45611   jresult = (int)result;
45612   return jresult;
45613 }
45614
45615
45616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45617   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45618
45619   arg1 = (Dali::BufferImage *)jarg1;
45620   {
45621     try {
45622       (arg1)->Update();
45623     } catch (std::out_of_range& e) {
45624       {
45625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45626       };
45627     } catch (std::exception& e) {
45628       {
45629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45630       };
45631     } catch (Dali::DaliException e) {
45632       {
45633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45634       };
45635     } catch (...) {
45636       {
45637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45638       };
45639     }
45640   }
45641
45642 }
45643
45644
45645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45646   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45647   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45648   Dali::RectArea *argp2 ;
45649
45650   arg1 = (Dali::BufferImage *)jarg1;
45651   argp2 = (Dali::RectArea *)jarg2;
45652   if (!argp2) {
45653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45654     return ;
45655   }
45656   arg2 = *argp2;
45657   {
45658     try {
45659       (arg1)->Update(arg2);
45660     } catch (std::out_of_range& e) {
45661       {
45662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45663       };
45664     } catch (std::exception& e) {
45665       {
45666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45667       };
45668     } catch (Dali::DaliException e) {
45669       {
45670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45671       };
45672     } catch (...) {
45673       {
45674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45675       };
45676     }
45677   }
45678
45679 }
45680
45681
45682 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45683   unsigned int jresult ;
45684   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45685   bool result;
45686
45687   arg1 = (Dali::BufferImage *)jarg1;
45688   {
45689     try {
45690       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45691     } catch (std::out_of_range& e) {
45692       {
45693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45694       };
45695     } catch (std::exception& e) {
45696       {
45697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45698       };
45699     } catch (Dali::DaliException e) {
45700       {
45701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45702       };
45703     } catch (...) {
45704       {
45705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45706       };
45707     }
45708   }
45709
45710   jresult = result;
45711   return jresult;
45712 }
45713
45714
45715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45716   void * jresult ;
45717   Dali::EncodedBufferImage *result = 0 ;
45718
45719   {
45720     try {
45721       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45722     } catch (std::out_of_range& e) {
45723       {
45724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45725       };
45726     } catch (std::exception& e) {
45727       {
45728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45729       };
45730     } catch (Dali::DaliException e) {
45731       {
45732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45733       };
45734     } catch (...) {
45735       {
45736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45737       };
45738     }
45739   }
45740
45741   jresult = (void *)result;
45742   return jresult;
45743 }
45744
45745
45746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45747   void * jresult ;
45748   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45749   std::size_t arg2 ;
45750   Dali::EncodedBufferImage result;
45751
45752   arg1 = (uint8_t *)jarg1;
45753   arg2 = (std::size_t)jarg2;
45754   {
45755     try {
45756       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45757     } catch (std::out_of_range& e) {
45758       {
45759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45760       };
45761     } catch (std::exception& e) {
45762       {
45763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45764       };
45765     } catch (Dali::DaliException e) {
45766       {
45767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45768       };
45769     } catch (...) {
45770       {
45771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45772       };
45773     }
45774   }
45775
45776   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45777   return jresult;
45778 }
45779
45780
45781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45782   void * jresult ;
45783   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45784   std::size_t arg2 ;
45785   Dali::ImageDimensions arg3 ;
45786   Dali::FittingMode::Type arg4 ;
45787   Dali::SamplingMode::Type arg5 ;
45788   bool arg6 ;
45789   Dali::ImageDimensions *argp3 ;
45790   Dali::EncodedBufferImage result;
45791
45792   arg1 = (uint8_t *)jarg1;
45793   arg2 = (std::size_t)jarg2;
45794   argp3 = (Dali::ImageDimensions *)jarg3;
45795   if (!argp3) {
45796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45797     return 0;
45798   }
45799   arg3 = *argp3;
45800   arg4 = (Dali::FittingMode::Type)jarg4;
45801   arg5 = (Dali::SamplingMode::Type)jarg5;
45802   arg6 = jarg6 ? true : false;
45803   {
45804     try {
45805       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45806     } catch (std::out_of_range& e) {
45807       {
45808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45809       };
45810     } catch (std::exception& e) {
45811       {
45812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45813       };
45814     } catch (Dali::DaliException e) {
45815       {
45816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45817       };
45818     } catch (...) {
45819       {
45820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45821       };
45822     }
45823   }
45824
45825   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45826   return jresult;
45827 }
45828
45829
45830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45831   void * jresult ;
45832   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45833   std::size_t arg2 ;
45834   Dali::ImageDimensions arg3 ;
45835   Dali::FittingMode::Type arg4 ;
45836   Dali::SamplingMode::Type arg5 ;
45837   Dali::ImageDimensions *argp3 ;
45838   Dali::EncodedBufferImage result;
45839
45840   arg1 = (uint8_t *)jarg1;
45841   arg2 = (std::size_t)jarg2;
45842   argp3 = (Dali::ImageDimensions *)jarg3;
45843   if (!argp3) {
45844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45845     return 0;
45846   }
45847   arg3 = *argp3;
45848   arg4 = (Dali::FittingMode::Type)jarg4;
45849   arg5 = (Dali::SamplingMode::Type)jarg5;
45850   {
45851     try {
45852       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45853     } catch (std::out_of_range& e) {
45854       {
45855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45856       };
45857     } catch (std::exception& e) {
45858       {
45859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45860       };
45861     } catch (Dali::DaliException e) {
45862       {
45863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45864       };
45865     } catch (...) {
45866       {
45867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45868       };
45869     }
45870   }
45871
45872   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45873   return jresult;
45874 }
45875
45876
45877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45878   void * jresult ;
45879   Dali::BaseHandle arg1 ;
45880   Dali::BaseHandle *argp1 ;
45881   Dali::EncodedBufferImage result;
45882
45883   argp1 = (Dali::BaseHandle *)jarg1;
45884   if (!argp1) {
45885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45886     return 0;
45887   }
45888   arg1 = *argp1;
45889   {
45890     try {
45891       result = Dali::EncodedBufferImage::DownCast(arg1);
45892     } catch (std::out_of_range& e) {
45893       {
45894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45895       };
45896     } catch (std::exception& e) {
45897       {
45898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45899       };
45900     } catch (Dali::DaliException e) {
45901       {
45902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45903       };
45904     } catch (...) {
45905       {
45906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45907       };
45908     }
45909   }
45910
45911   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45912   return jresult;
45913 }
45914
45915
45916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45917   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45918
45919   arg1 = (Dali::EncodedBufferImage *)jarg1;
45920   {
45921     try {
45922       delete arg1;
45923     } catch (std::out_of_range& e) {
45924       {
45925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45926       };
45927     } catch (std::exception& e) {
45928       {
45929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45930       };
45931     } catch (Dali::DaliException e) {
45932       {
45933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45934       };
45935     } catch (...) {
45936       {
45937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45938       };
45939     }
45940   }
45941
45942 }
45943
45944
45945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45946   void * jresult ;
45947   Dali::EncodedBufferImage *arg1 = 0 ;
45948   Dali::EncodedBufferImage *result = 0 ;
45949
45950   arg1 = (Dali::EncodedBufferImage *)jarg1;
45951   if (!arg1) {
45952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45953     return 0;
45954   }
45955   {
45956     try {
45957       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45958     } catch (std::out_of_range& e) {
45959       {
45960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45961       };
45962     } catch (std::exception& e) {
45963       {
45964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45965       };
45966     } catch (Dali::DaliException e) {
45967       {
45968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45969       };
45970     } catch (...) {
45971       {
45972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45973       };
45974     }
45975   }
45976
45977   jresult = (void *)result;
45978   return jresult;
45979 }
45980
45981
45982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45983   void * jresult ;
45984   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45985   Dali::EncodedBufferImage *arg2 = 0 ;
45986   Dali::EncodedBufferImage *result = 0 ;
45987
45988   arg1 = (Dali::EncodedBufferImage *)jarg1;
45989   arg2 = (Dali::EncodedBufferImage *)jarg2;
45990   if (!arg2) {
45991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45992     return 0;
45993   }
45994   {
45995     try {
45996       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45997     } catch (std::out_of_range& e) {
45998       {
45999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46000       };
46001     } catch (std::exception& e) {
46002       {
46003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46004       };
46005     } catch (Dali::DaliException e) {
46006       {
46007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46008       };
46009     } catch (...) {
46010       {
46011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46012       };
46013     }
46014   }
46015
46016   jresult = (void *)result;
46017   return jresult;
46018 }
46019
46020
46021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
46022   void * jresult ;
46023   Dali::NativeImage *result = 0 ;
46024
46025   {
46026     try {
46027       result = (Dali::NativeImage *)new Dali::NativeImage();
46028     } catch (std::out_of_range& e) {
46029       {
46030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46031       };
46032     } catch (std::exception& e) {
46033       {
46034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46035       };
46036     } catch (Dali::DaliException e) {
46037       {
46038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46039       };
46040     } catch (...) {
46041       {
46042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46043       };
46044     }
46045   }
46046
46047   jresult = (void *)result;
46048   return jresult;
46049 }
46050
46051
46052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
46053   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46054
46055   arg1 = (Dali::NativeImage *)jarg1;
46056   {
46057     try {
46058       delete arg1;
46059     } catch (std::out_of_range& e) {
46060       {
46061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46062       };
46063     } catch (std::exception& e) {
46064       {
46065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46066       };
46067     } catch (Dali::DaliException e) {
46068       {
46069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46070       };
46071     } catch (...) {
46072       {
46073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46074       };
46075     }
46076   }
46077
46078 }
46079
46080
46081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
46082   void * jresult ;
46083   Dali::NativeImage *arg1 = 0 ;
46084   Dali::NativeImage *result = 0 ;
46085
46086   arg1 = (Dali::NativeImage *)jarg1;
46087   if (!arg1) {
46088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46089     return 0;
46090   }
46091   {
46092     try {
46093       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46094     } catch (std::out_of_range& e) {
46095       {
46096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46097       };
46098     } catch (std::exception& e) {
46099       {
46100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46101       };
46102     } catch (Dali::DaliException e) {
46103       {
46104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46105       };
46106     } catch (...) {
46107       {
46108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46109       };
46110     }
46111   }
46112
46113   jresult = (void *)result;
46114   return jresult;
46115 }
46116
46117
46118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46119   void * jresult ;
46120   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46121   Dali::NativeImage *arg2 = 0 ;
46122   Dali::NativeImage *result = 0 ;
46123
46124   arg1 = (Dali::NativeImage *)jarg1;
46125   arg2 = (Dali::NativeImage *)jarg2;
46126   if (!arg2) {
46127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46128     return 0;
46129   }
46130   {
46131     try {
46132       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46133     } catch (std::out_of_range& e) {
46134       {
46135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46136       };
46137     } catch (std::exception& e) {
46138       {
46139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46140       };
46141     } catch (Dali::DaliException e) {
46142       {
46143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46144       };
46145     } catch (...) {
46146       {
46147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46148       };
46149     }
46150   }
46151
46152   jresult = (void *)result;
46153   return jresult;
46154 }
46155
46156
46157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46158   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46159
46160   arg1 = (Dali::NativeImage *)jarg1;
46161   {
46162     try {
46163       (arg1)->CreateGlTexture();
46164     } catch (std::out_of_range& e) {
46165       {
46166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46167       };
46168     } catch (std::exception& e) {
46169       {
46170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46171       };
46172     } catch (Dali::DaliException e) {
46173       {
46174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46175       };
46176     } catch (...) {
46177       {
46178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46179       };
46180     }
46181   }
46182
46183 }
46184
46185
46186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46187   void * jresult ;
46188   NativeImageInterface *arg1 = 0 ;
46189   Dali::NativeImage result;
46190
46191   arg1 = (NativeImageInterface *)jarg1;
46192   if (!arg1) {
46193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46194     return 0;
46195   }
46196   {
46197     try {
46198       result = Dali::NativeImage::New(*arg1);
46199     } catch (std::out_of_range& e) {
46200       {
46201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46202       };
46203     } catch (std::exception& e) {
46204       {
46205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46206       };
46207     } catch (Dali::DaliException e) {
46208       {
46209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46210       };
46211     } catch (...) {
46212       {
46213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46214       };
46215     }
46216   }
46217
46218   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46219   return jresult;
46220 }
46221
46222
46223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46224   void * jresult ;
46225   Dali::BaseHandle arg1 ;
46226   Dali::BaseHandle *argp1 ;
46227   Dali::NativeImage result;
46228
46229   argp1 = (Dali::BaseHandle *)jarg1;
46230   if (!argp1) {
46231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46232     return 0;
46233   }
46234   arg1 = *argp1;
46235   {
46236     try {
46237       result = Dali::NativeImage::DownCast(arg1);
46238     } catch (std::out_of_range& e) {
46239       {
46240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46241       };
46242     } catch (std::exception& e) {
46243       {
46244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46245       };
46246     } catch (Dali::DaliException e) {
46247       {
46248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46249       };
46250     } catch (...) {
46251       {
46252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46253       };
46254     }
46255   }
46256
46257   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46258   return jresult;
46259 }
46260
46261
46262 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46263   char * jresult ;
46264   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46265   char *result = 0 ;
46266
46267   arg1 = (Dali::NativeImage *)jarg1;
46268   {
46269     try {
46270       result = (char *)(arg1)->GetCustomFragmentPreFix();
46271     } catch (std::out_of_range& e) {
46272       {
46273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46274       };
46275     } catch (std::exception& e) {
46276       {
46277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46278       };
46279     } catch (Dali::DaliException e) {
46280       {
46281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46282       };
46283     } catch (...) {
46284       {
46285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46286       };
46287     }
46288   }
46289
46290   jresult = SWIG_csharp_string_callback((const char *)result);
46291   return jresult;
46292 }
46293
46294
46295 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46296   char * jresult ;
46297   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46298   char *result = 0 ;
46299
46300   arg1 = (Dali::NativeImage *)jarg1;
46301   {
46302     try {
46303       result = (char *)(arg1)->GetCustomSamplerTypename();
46304     } catch (std::out_of_range& e) {
46305       {
46306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46307       };
46308     } catch (std::exception& e) {
46309       {
46310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46311       };
46312     } catch (Dali::DaliException e) {
46313       {
46314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46315       };
46316     } catch (...) {
46317       {
46318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46319       };
46320     }
46321   }
46322
46323   jresult = SWIG_csharp_string_callback((const char *)result);
46324   return jresult;
46325 }
46326
46327
46328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46329   unsigned int jresult ;
46330   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46331   bool result;
46332
46333   arg1 = (Dali::NativeImageInterface *)jarg1;
46334   {
46335     try {
46336       result = (bool)(arg1)->GlExtensionCreate();
46337     } catch (std::out_of_range& e) {
46338       {
46339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46340       };
46341     } catch (std::exception& e) {
46342       {
46343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46344       };
46345     } catch (Dali::DaliException e) {
46346       {
46347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46348       };
46349     } catch (...) {
46350       {
46351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46352       };
46353     }
46354   }
46355
46356   jresult = result;
46357   return jresult;
46358 }
46359
46360
46361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46362   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46363
46364   arg1 = (Dali::NativeImageInterface *)jarg1;
46365   {
46366     try {
46367       (arg1)->GlExtensionDestroy();
46368     } catch (std::out_of_range& e) {
46369       {
46370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46371       };
46372     } catch (std::exception& e) {
46373       {
46374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46375       };
46376     } catch (Dali::DaliException e) {
46377       {
46378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46379       };
46380     } catch (...) {
46381       {
46382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46383       };
46384     }
46385   }
46386
46387 }
46388
46389
46390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46391   unsigned int jresult ;
46392   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46393   unsigned int result;
46394
46395   arg1 = (Dali::NativeImageInterface *)jarg1;
46396   {
46397     try {
46398       result = (unsigned int)(arg1)->TargetTexture();
46399     } catch (std::out_of_range& e) {
46400       {
46401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46402       };
46403     } catch (std::exception& e) {
46404       {
46405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46406       };
46407     } catch (Dali::DaliException e) {
46408       {
46409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46410       };
46411     } catch (...) {
46412       {
46413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46414       };
46415     }
46416   }
46417
46418   jresult = result;
46419   return jresult;
46420 }
46421
46422
46423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46424   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46425
46426   arg1 = (Dali::NativeImageInterface *)jarg1;
46427   {
46428     try {
46429       (arg1)->PrepareTexture();
46430     } catch (std::out_of_range& e) {
46431       {
46432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46433       };
46434     } catch (std::exception& e) {
46435       {
46436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46437       };
46438     } catch (Dali::DaliException e) {
46439       {
46440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46441       };
46442     } catch (...) {
46443       {
46444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46445       };
46446     }
46447   }
46448
46449 }
46450
46451
46452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46453   unsigned int jresult ;
46454   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46455   unsigned int result;
46456
46457   arg1 = (Dali::NativeImageInterface *)jarg1;
46458   {
46459     try {
46460       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46461     } catch (std::out_of_range& e) {
46462       {
46463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46464       };
46465     } catch (std::exception& e) {
46466       {
46467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46468       };
46469     } catch (Dali::DaliException e) {
46470       {
46471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46472       };
46473     } catch (...) {
46474       {
46475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46476       };
46477     }
46478   }
46479
46480   jresult = result;
46481   return jresult;
46482 }
46483
46484
46485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46486   unsigned int jresult ;
46487   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46488   unsigned int result;
46489
46490   arg1 = (Dali::NativeImageInterface *)jarg1;
46491   {
46492     try {
46493       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46494     } catch (std::out_of_range& e) {
46495       {
46496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46497       };
46498     } catch (std::exception& e) {
46499       {
46500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46501       };
46502     } catch (Dali::DaliException e) {
46503       {
46504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46505       };
46506     } catch (...) {
46507       {
46508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46509       };
46510     }
46511   }
46512
46513   jresult = result;
46514   return jresult;
46515 }
46516
46517
46518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46519   unsigned int jresult ;
46520   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46521   bool result;
46522
46523   arg1 = (Dali::NativeImageInterface *)jarg1;
46524   {
46525     try {
46526       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46527     } catch (std::out_of_range& e) {
46528       {
46529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46530       };
46531     } catch (std::exception& e) {
46532       {
46533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46534       };
46535     } catch (Dali::DaliException e) {
46536       {
46537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46538       };
46539     } catch (...) {
46540       {
46541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46542       };
46543     }
46544   }
46545
46546   jresult = result;
46547   return jresult;
46548 }
46549
46550
46551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46552   void * jresult ;
46553   std::string *arg1 = 0 ;
46554   Dali::ImageDimensions result;
46555
46556   if (!jarg1) {
46557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46558     return 0;
46559   }
46560   std::string arg1_str(jarg1);
46561   arg1 = &arg1_str;
46562   {
46563     try {
46564       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46565     } catch (std::out_of_range& e) {
46566       {
46567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46568       };
46569     } catch (std::exception& e) {
46570       {
46571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46572       };
46573     } catch (Dali::DaliException e) {
46574       {
46575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46576       };
46577     } catch (...) {
46578       {
46579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46580       };
46581     }
46582   }
46583
46584   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46585
46586   //argout typemap for const std::string&
46587
46588   return jresult;
46589 }
46590
46591
46592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46593   void * jresult ;
46594   Dali::ResourceImage *result = 0 ;
46595
46596   {
46597     try {
46598       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46599     } catch (std::out_of_range& e) {
46600       {
46601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46602       };
46603     } catch (std::exception& e) {
46604       {
46605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46606       };
46607     } catch (Dali::DaliException e) {
46608       {
46609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46610       };
46611     } catch (...) {
46612       {
46613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46614       };
46615     }
46616   }
46617
46618   jresult = (void *)result;
46619   return jresult;
46620 }
46621
46622
46623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46624   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46625
46626   arg1 = (Dali::ResourceImage *)jarg1;
46627   {
46628     try {
46629       delete arg1;
46630     } catch (std::out_of_range& e) {
46631       {
46632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46633       };
46634     } catch (std::exception& e) {
46635       {
46636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46637       };
46638     } catch (Dali::DaliException e) {
46639       {
46640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46641       };
46642     } catch (...) {
46643       {
46644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46645       };
46646     }
46647   }
46648
46649 }
46650
46651
46652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46653   void * jresult ;
46654   Dali::ResourceImage *arg1 = 0 ;
46655   Dali::ResourceImage *result = 0 ;
46656
46657   arg1 = (Dali::ResourceImage *)jarg1;
46658   if (!arg1) {
46659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46660     return 0;
46661   }
46662   {
46663     try {
46664       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46665     } catch (std::out_of_range& e) {
46666       {
46667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46668       };
46669     } catch (std::exception& e) {
46670       {
46671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46672       };
46673     } catch (Dali::DaliException e) {
46674       {
46675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46676       };
46677     } catch (...) {
46678       {
46679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46680       };
46681     }
46682   }
46683
46684   jresult = (void *)result;
46685   return jresult;
46686 }
46687
46688
46689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46690   void * jresult ;
46691   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46692   Dali::ResourceImage *arg2 = 0 ;
46693   Dali::ResourceImage *result = 0 ;
46694
46695   arg1 = (Dali::ResourceImage *)jarg1;
46696   arg2 = (Dali::ResourceImage *)jarg2;
46697   if (!arg2) {
46698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46699     return 0;
46700   }
46701   {
46702     try {
46703       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46704     } catch (std::out_of_range& e) {
46705       {
46706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46707       };
46708     } catch (std::exception& e) {
46709       {
46710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46711       };
46712     } catch (Dali::DaliException e) {
46713       {
46714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46715       };
46716     } catch (...) {
46717       {
46718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46719       };
46720     }
46721   }
46722
46723   jresult = (void *)result;
46724   return jresult;
46725 }
46726
46727
46728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46729   void * jresult ;
46730   std::string *arg1 = 0 ;
46731   bool arg2 ;
46732   Dali::ResourceImage result;
46733
46734   if (!jarg1) {
46735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46736     return 0;
46737   }
46738   std::string arg1_str(jarg1);
46739   arg1 = &arg1_str;
46740   arg2 = jarg2 ? true : false;
46741   {
46742     try {
46743       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46744     } catch (std::out_of_range& e) {
46745       {
46746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46747       };
46748     } catch (std::exception& e) {
46749       {
46750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46751       };
46752     } catch (Dali::DaliException e) {
46753       {
46754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46755       };
46756     } catch (...) {
46757       {
46758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46759       };
46760     }
46761   }
46762
46763   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46764
46765   //argout typemap for const std::string&
46766
46767   return jresult;
46768 }
46769
46770
46771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46772   void * jresult ;
46773   std::string *arg1 = 0 ;
46774   Dali::ResourceImage result;
46775
46776   if (!jarg1) {
46777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46778     return 0;
46779   }
46780   std::string arg1_str(jarg1);
46781   arg1 = &arg1_str;
46782   {
46783     try {
46784       result = Dali::ResourceImage::New((std::string const &)*arg1);
46785     } catch (std::out_of_range& e) {
46786       {
46787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46788       };
46789     } catch (std::exception& e) {
46790       {
46791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46792       };
46793     } catch (Dali::DaliException e) {
46794       {
46795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46796       };
46797     } catch (...) {
46798       {
46799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46800       };
46801     }
46802   }
46803
46804   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46805
46806   //argout typemap for const std::string&
46807
46808   return jresult;
46809 }
46810
46811
46812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46813   void * jresult ;
46814   std::string *arg1 = 0 ;
46815   Dali::ImageDimensions arg2 ;
46816   Dali::FittingMode::Type arg3 ;
46817   Dali::SamplingMode::Type arg4 ;
46818   bool arg5 ;
46819   Dali::ImageDimensions *argp2 ;
46820   Dali::ResourceImage result;
46821
46822   if (!jarg1) {
46823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46824     return 0;
46825   }
46826   std::string arg1_str(jarg1);
46827   arg1 = &arg1_str;
46828   argp2 = (Dali::ImageDimensions *)jarg2;
46829   if (!argp2) {
46830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46831     return 0;
46832   }
46833   arg2 = *argp2;
46834   arg3 = (Dali::FittingMode::Type)jarg3;
46835   arg4 = (Dali::SamplingMode::Type)jarg4;
46836   arg5 = jarg5 ? true : false;
46837   {
46838     try {
46839       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46840     } catch (std::out_of_range& e) {
46841       {
46842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46843       };
46844     } catch (std::exception& e) {
46845       {
46846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46847       };
46848     } catch (Dali::DaliException e) {
46849       {
46850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46851       };
46852     } catch (...) {
46853       {
46854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46855       };
46856     }
46857   }
46858
46859   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46860
46861   //argout typemap for const std::string&
46862
46863   return jresult;
46864 }
46865
46866
46867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46868   void * jresult ;
46869   std::string *arg1 = 0 ;
46870   Dali::ImageDimensions arg2 ;
46871   Dali::FittingMode::Type arg3 ;
46872   Dali::SamplingMode::Type arg4 ;
46873   Dali::ImageDimensions *argp2 ;
46874   Dali::ResourceImage result;
46875
46876   if (!jarg1) {
46877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46878     return 0;
46879   }
46880   std::string arg1_str(jarg1);
46881   arg1 = &arg1_str;
46882   argp2 = (Dali::ImageDimensions *)jarg2;
46883   if (!argp2) {
46884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46885     return 0;
46886   }
46887   arg2 = *argp2;
46888   arg3 = (Dali::FittingMode::Type)jarg3;
46889   arg4 = (Dali::SamplingMode::Type)jarg4;
46890   {
46891     try {
46892       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46893     } catch (std::out_of_range& e) {
46894       {
46895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46896       };
46897     } catch (std::exception& e) {
46898       {
46899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46900       };
46901     } catch (Dali::DaliException e) {
46902       {
46903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46904       };
46905     } catch (...) {
46906       {
46907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46908       };
46909     }
46910   }
46911
46912   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46913
46914   //argout typemap for const std::string&
46915
46916   return jresult;
46917 }
46918
46919
46920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46921   void * jresult ;
46922   std::string *arg1 = 0 ;
46923   Dali::ImageDimensions arg2 ;
46924   Dali::FittingMode::Type arg3 ;
46925   Dali::ImageDimensions *argp2 ;
46926   Dali::ResourceImage result;
46927
46928   if (!jarg1) {
46929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46930     return 0;
46931   }
46932   std::string arg1_str(jarg1);
46933   arg1 = &arg1_str;
46934   argp2 = (Dali::ImageDimensions *)jarg2;
46935   if (!argp2) {
46936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46937     return 0;
46938   }
46939   arg2 = *argp2;
46940   arg3 = (Dali::FittingMode::Type)jarg3;
46941   {
46942     try {
46943       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46944     } catch (std::out_of_range& e) {
46945       {
46946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46947       };
46948     } catch (std::exception& e) {
46949       {
46950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46951       };
46952     } catch (Dali::DaliException e) {
46953       {
46954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46955       };
46956     } catch (...) {
46957       {
46958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46959       };
46960     }
46961   }
46962
46963   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46964
46965   //argout typemap for const std::string&
46966
46967   return jresult;
46968 }
46969
46970
46971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46972   void * jresult ;
46973   std::string *arg1 = 0 ;
46974   Dali::ImageDimensions arg2 ;
46975   Dali::ImageDimensions *argp2 ;
46976   Dali::ResourceImage result;
46977
46978   if (!jarg1) {
46979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46980     return 0;
46981   }
46982   std::string arg1_str(jarg1);
46983   arg1 = &arg1_str;
46984   argp2 = (Dali::ImageDimensions *)jarg2;
46985   if (!argp2) {
46986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46987     return 0;
46988   }
46989   arg2 = *argp2;
46990   {
46991     try {
46992       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46993     } catch (std::out_of_range& e) {
46994       {
46995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46996       };
46997     } catch (std::exception& e) {
46998       {
46999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47000       };
47001     } catch (Dali::DaliException e) {
47002       {
47003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47004       };
47005     } catch (...) {
47006       {
47007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47008       };
47009     }
47010   }
47011
47012   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47013
47014   //argout typemap for const std::string&
47015
47016   return jresult;
47017 }
47018
47019
47020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
47021   void * jresult ;
47022   Dali::BaseHandle arg1 ;
47023   Dali::BaseHandle *argp1 ;
47024   Dali::ResourceImage result;
47025
47026   argp1 = (Dali::BaseHandle *)jarg1;
47027   if (!argp1) {
47028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47029     return 0;
47030   }
47031   arg1 = *argp1;
47032   {
47033     try {
47034       result = Dali::ResourceImage::DownCast(arg1);
47035     } catch (std::out_of_range& e) {
47036       {
47037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47038       };
47039     } catch (std::exception& e) {
47040       {
47041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47042       };
47043     } catch (Dali::DaliException e) {
47044       {
47045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47046       };
47047     } catch (...) {
47048       {
47049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47050       };
47051     }
47052   }
47053
47054   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47055   return jresult;
47056 }
47057
47058
47059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
47060   int jresult ;
47061   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47062   Dali::LoadingState result;
47063
47064   arg1 = (Dali::ResourceImage *)jarg1;
47065   {
47066     try {
47067       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
47068     } catch (std::out_of_range& e) {
47069       {
47070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47071       };
47072     } catch (std::exception& e) {
47073       {
47074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47075       };
47076     } catch (Dali::DaliException e) {
47077       {
47078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47079       };
47080     } catch (...) {
47081       {
47082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47083       };
47084     }
47085   }
47086
47087   jresult = (int)result;
47088   return jresult;
47089 }
47090
47091
47092 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47093   char * jresult ;
47094   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47095   std::string result;
47096
47097   arg1 = (Dali::ResourceImage *)jarg1;
47098   {
47099     try {
47100       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47101     } catch (std::out_of_range& e) {
47102       {
47103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47104       };
47105     } catch (std::exception& e) {
47106       {
47107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47108       };
47109     } catch (Dali::DaliException e) {
47110       {
47111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47112       };
47113     } catch (...) {
47114       {
47115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47116       };
47117     }
47118   }
47119
47120   jresult = SWIG_csharp_string_callback((&result)->c_str());
47121   return jresult;
47122 }
47123
47124
47125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47126   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47127
47128   arg1 = (Dali::ResourceImage *)jarg1;
47129   {
47130     try {
47131       (arg1)->Reload();
47132     } catch (std::out_of_range& e) {
47133       {
47134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47135       };
47136     } catch (std::exception& e) {
47137       {
47138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47139       };
47140     } catch (Dali::DaliException e) {
47141       {
47142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47143       };
47144     } catch (...) {
47145       {
47146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47147       };
47148     }
47149   }
47150
47151 }
47152
47153
47154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47155   void * jresult ;
47156   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47157   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47158
47159   arg1 = (Dali::ResourceImage *)jarg1;
47160   {
47161     try {
47162       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47163     } catch (std::out_of_range& e) {
47164       {
47165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47166       };
47167     } catch (std::exception& e) {
47168       {
47169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47170       };
47171     } catch (Dali::DaliException e) {
47172       {
47173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47174       };
47175     } catch (...) {
47176       {
47177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47178       };
47179     }
47180   }
47181
47182   jresult = (void *)result;
47183   return jresult;
47184 }
47185
47186
47187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47188   void * jresult ;
47189   Dali::FrameBufferImage *result = 0 ;
47190
47191   {
47192     try {
47193       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47194     } catch (std::out_of_range& e) {
47195       {
47196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47197       };
47198     } catch (std::exception& e) {
47199       {
47200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47201       };
47202     } catch (Dali::DaliException e) {
47203       {
47204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47205       };
47206     } catch (...) {
47207       {
47208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47209       };
47210     }
47211   }
47212
47213   jresult = (void *)result;
47214   return jresult;
47215 }
47216
47217
47218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47219   void * jresult ;
47220   unsigned int arg1 ;
47221   unsigned int arg2 ;
47222   Dali::Pixel::Format arg3 ;
47223   Dali::RenderBuffer::Format arg4 ;
47224   Dali::FrameBufferImage result;
47225
47226   arg1 = (unsigned int)jarg1;
47227   arg2 = (unsigned int)jarg2;
47228   arg3 = (Dali::Pixel::Format)jarg3;
47229   arg4 = (Dali::RenderBuffer::Format)jarg4;
47230   {
47231     try {
47232       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47233     } catch (std::out_of_range& e) {
47234       {
47235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47236       };
47237     } catch (std::exception& e) {
47238       {
47239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47240       };
47241     } catch (Dali::DaliException e) {
47242       {
47243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47244       };
47245     } catch (...) {
47246       {
47247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47248       };
47249     }
47250   }
47251
47252   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47253   return jresult;
47254 }
47255
47256
47257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47258   void * jresult ;
47259   unsigned int arg1 ;
47260   unsigned int arg2 ;
47261   Dali::Pixel::Format arg3 ;
47262   Dali::FrameBufferImage result;
47263
47264   arg1 = (unsigned int)jarg1;
47265   arg2 = (unsigned int)jarg2;
47266   arg3 = (Dali::Pixel::Format)jarg3;
47267   {
47268     try {
47269       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47270     } catch (std::out_of_range& e) {
47271       {
47272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47273       };
47274     } catch (std::exception& e) {
47275       {
47276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47277       };
47278     } catch (Dali::DaliException e) {
47279       {
47280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47281       };
47282     } catch (...) {
47283       {
47284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47285       };
47286     }
47287   }
47288
47289   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47290   return jresult;
47291 }
47292
47293
47294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47295   void * jresult ;
47296   unsigned int arg1 ;
47297   unsigned int arg2 ;
47298   Dali::FrameBufferImage result;
47299
47300   arg1 = (unsigned int)jarg1;
47301   arg2 = (unsigned int)jarg2;
47302   {
47303     try {
47304       result = Dali::FrameBufferImage::New(arg1,arg2);
47305     } catch (std::out_of_range& e) {
47306       {
47307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47308       };
47309     } catch (std::exception& e) {
47310       {
47311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47312       };
47313     } catch (Dali::DaliException e) {
47314       {
47315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47316       };
47317     } catch (...) {
47318       {
47319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47320       };
47321     }
47322   }
47323
47324   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47325   return jresult;
47326 }
47327
47328
47329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47330   void * jresult ;
47331   unsigned int arg1 ;
47332   Dali::FrameBufferImage result;
47333
47334   arg1 = (unsigned int)jarg1;
47335   {
47336     try {
47337       result = Dali::FrameBufferImage::New(arg1);
47338     } catch (std::out_of_range& e) {
47339       {
47340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47341       };
47342     } catch (std::exception& e) {
47343       {
47344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47345       };
47346     } catch (Dali::DaliException e) {
47347       {
47348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47349       };
47350     } catch (...) {
47351       {
47352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47353       };
47354     }
47355   }
47356
47357   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47358   return jresult;
47359 }
47360
47361
47362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47363   void * jresult ;
47364   Dali::FrameBufferImage result;
47365
47366   {
47367     try {
47368       result = Dali::FrameBufferImage::New();
47369     } catch (std::out_of_range& e) {
47370       {
47371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47372       };
47373     } catch (std::exception& e) {
47374       {
47375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47376       };
47377     } catch (Dali::DaliException e) {
47378       {
47379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47380       };
47381     } catch (...) {
47382       {
47383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47384       };
47385     }
47386   }
47387
47388   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47389   return jresult;
47390 }
47391
47392
47393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47394   void * jresult ;
47395   Dali::NativeImageInterface *arg1 = 0 ;
47396   Dali::FrameBufferImage result;
47397
47398   arg1 = (Dali::NativeImageInterface *)jarg1;
47399   if (!arg1) {
47400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47401     return 0;
47402   }
47403   {
47404     try {
47405       result = Dali::FrameBufferImage::New(*arg1);
47406     } catch (std::out_of_range& e) {
47407       {
47408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47409       };
47410     } catch (std::exception& e) {
47411       {
47412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47413       };
47414     } catch (Dali::DaliException e) {
47415       {
47416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47417       };
47418     } catch (...) {
47419       {
47420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47421       };
47422     }
47423   }
47424
47425   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47426   return jresult;
47427 }
47428
47429
47430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47431   void * jresult ;
47432   Dali::BaseHandle arg1 ;
47433   Dali::BaseHandle *argp1 ;
47434   Dali::FrameBufferImage result;
47435
47436   argp1 = (Dali::BaseHandle *)jarg1;
47437   if (!argp1) {
47438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47439     return 0;
47440   }
47441   arg1 = *argp1;
47442   {
47443     try {
47444       result = Dali::FrameBufferImage::DownCast(arg1);
47445     } catch (std::out_of_range& e) {
47446       {
47447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47448       };
47449     } catch (std::exception& e) {
47450       {
47451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47452       };
47453     } catch (Dali::DaliException e) {
47454       {
47455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47456       };
47457     } catch (...) {
47458       {
47459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47460       };
47461     }
47462   }
47463
47464   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47465   return jresult;
47466 }
47467
47468
47469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47470   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47471
47472   arg1 = (Dali::FrameBufferImage *)jarg1;
47473   {
47474     try {
47475       delete arg1;
47476     } catch (std::out_of_range& e) {
47477       {
47478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47479       };
47480     } catch (std::exception& e) {
47481       {
47482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47483       };
47484     } catch (Dali::DaliException e) {
47485       {
47486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47487       };
47488     } catch (...) {
47489       {
47490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47491       };
47492     }
47493   }
47494
47495 }
47496
47497
47498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47499   void * jresult ;
47500   Dali::FrameBufferImage *arg1 = 0 ;
47501   Dali::FrameBufferImage *result = 0 ;
47502
47503   arg1 = (Dali::FrameBufferImage *)jarg1;
47504   if (!arg1) {
47505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47506     return 0;
47507   }
47508   {
47509     try {
47510       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47511     } catch (std::out_of_range& e) {
47512       {
47513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47514       };
47515     } catch (std::exception& e) {
47516       {
47517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47518       };
47519     } catch (Dali::DaliException e) {
47520       {
47521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47522       };
47523     } catch (...) {
47524       {
47525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47526       };
47527     }
47528   }
47529
47530   jresult = (void *)result;
47531   return jresult;
47532 }
47533
47534
47535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47536   void * jresult ;
47537   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47538   Dali::FrameBufferImage *arg2 = 0 ;
47539   Dali::FrameBufferImage *result = 0 ;
47540
47541   arg1 = (Dali::FrameBufferImage *)jarg1;
47542   arg2 = (Dali::FrameBufferImage *)jarg2;
47543   if (!arg2) {
47544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47545     return 0;
47546   }
47547   {
47548     try {
47549       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47550     } catch (std::out_of_range& e) {
47551       {
47552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47553       };
47554     } catch (std::exception& e) {
47555       {
47556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47557       };
47558     } catch (Dali::DaliException e) {
47559       {
47560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47561       };
47562     } catch (...) {
47563       {
47564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47565       };
47566     }
47567   }
47568
47569   jresult = (void *)result;
47570   return jresult;
47571 }
47572
47573
47574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47575   void * jresult ;
47576   Dali::NinePatchImage *result = 0 ;
47577
47578   {
47579     try {
47580       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47581     } catch (std::out_of_range& e) {
47582       {
47583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47584       };
47585     } catch (std::exception& e) {
47586       {
47587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47588       };
47589     } catch (Dali::DaliException e) {
47590       {
47591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47592       };
47593     } catch (...) {
47594       {
47595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47596       };
47597     }
47598   }
47599
47600   jresult = (void *)result;
47601   return jresult;
47602 }
47603
47604
47605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47606   void * jresult ;
47607   std::string *arg1 = 0 ;
47608   Dali::NinePatchImage result;
47609
47610   if (!jarg1) {
47611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47612     return 0;
47613   }
47614   std::string arg1_str(jarg1);
47615   arg1 = &arg1_str;
47616   {
47617     try {
47618       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47619     } catch (std::out_of_range& e) {
47620       {
47621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47622       };
47623     } catch (std::exception& e) {
47624       {
47625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47626       };
47627     } catch (Dali::DaliException e) {
47628       {
47629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47630       };
47631     } catch (...) {
47632       {
47633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47634       };
47635     }
47636   }
47637
47638   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47639
47640   //argout typemap for const std::string&
47641
47642   return jresult;
47643 }
47644
47645
47646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47647   void * jresult ;
47648   Dali::BaseHandle arg1 ;
47649   Dali::BaseHandle *argp1 ;
47650   Dali::NinePatchImage result;
47651
47652   argp1 = (Dali::BaseHandle *)jarg1;
47653   if (!argp1) {
47654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47655     return 0;
47656   }
47657   arg1 = *argp1;
47658   {
47659     try {
47660       result = Dali::NinePatchImage::DownCast(arg1);
47661     } catch (std::out_of_range& e) {
47662       {
47663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47664       };
47665     } catch (std::exception& e) {
47666       {
47667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47668       };
47669     } catch (Dali::DaliException e) {
47670       {
47671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47672       };
47673     } catch (...) {
47674       {
47675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47676       };
47677     }
47678   }
47679
47680   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47681   return jresult;
47682 }
47683
47684
47685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47686   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47687
47688   arg1 = (Dali::NinePatchImage *)jarg1;
47689   {
47690     try {
47691       delete arg1;
47692     } catch (std::out_of_range& e) {
47693       {
47694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47695       };
47696     } catch (std::exception& e) {
47697       {
47698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47699       };
47700     } catch (Dali::DaliException e) {
47701       {
47702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47703       };
47704     } catch (...) {
47705       {
47706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47707       };
47708     }
47709   }
47710
47711 }
47712
47713
47714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47715   void * jresult ;
47716   Dali::NinePatchImage *arg1 = 0 ;
47717   Dali::NinePatchImage *result = 0 ;
47718
47719   arg1 = (Dali::NinePatchImage *)jarg1;
47720   if (!arg1) {
47721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47722     return 0;
47723   }
47724   {
47725     try {
47726       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47727     } catch (std::out_of_range& e) {
47728       {
47729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47730       };
47731     } catch (std::exception& e) {
47732       {
47733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47734       };
47735     } catch (Dali::DaliException e) {
47736       {
47737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47738       };
47739     } catch (...) {
47740       {
47741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47742       };
47743     }
47744   }
47745
47746   jresult = (void *)result;
47747   return jresult;
47748 }
47749
47750
47751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47752   void * jresult ;
47753   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47754   Dali::NinePatchImage *arg2 = 0 ;
47755   Dali::NinePatchImage *result = 0 ;
47756
47757   arg1 = (Dali::NinePatchImage *)jarg1;
47758   arg2 = (Dali::NinePatchImage *)jarg2;
47759   if (!arg2) {
47760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47761     return 0;
47762   }
47763   {
47764     try {
47765       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47766     } catch (std::out_of_range& e) {
47767       {
47768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47769       };
47770     } catch (std::exception& e) {
47771       {
47772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47773       };
47774     } catch (Dali::DaliException e) {
47775       {
47776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47777       };
47778     } catch (...) {
47779       {
47780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47781       };
47782     }
47783   }
47784
47785   jresult = (void *)result;
47786   return jresult;
47787 }
47788
47789
47790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47791   void * jresult ;
47792   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47793   Dali::Vector4 result;
47794
47795   arg1 = (Dali::NinePatchImage *)jarg1;
47796   {
47797     try {
47798       result = (arg1)->GetStretchBorders();
47799     } catch (std::out_of_range& e) {
47800       {
47801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47802       };
47803     } catch (std::exception& e) {
47804       {
47805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47806       };
47807     } catch (Dali::DaliException e) {
47808       {
47809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47810       };
47811     } catch (...) {
47812       {
47813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47814       };
47815     }
47816   }
47817
47818   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47819   return jresult;
47820 }
47821
47822
47823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47824   void * jresult ;
47825   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47826   Dali::NinePatchImage::StretchRanges *result = 0 ;
47827
47828   arg1 = (Dali::NinePatchImage *)jarg1;
47829   {
47830     try {
47831       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47832     } catch (std::out_of_range& e) {
47833       {
47834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47835       };
47836     } catch (std::exception& e) {
47837       {
47838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47839       };
47840     } catch (Dali::DaliException e) {
47841       {
47842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47843       };
47844     } catch (...) {
47845       {
47846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47847       };
47848     }
47849   }
47850
47851   jresult = (void *)result;
47852   return jresult;
47853 }
47854
47855
47856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47857   void * jresult ;
47858   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47859   Dali::NinePatchImage::StretchRanges *result = 0 ;
47860
47861   arg1 = (Dali::NinePatchImage *)jarg1;
47862   {
47863     try {
47864       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47865     } catch (std::out_of_range& e) {
47866       {
47867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47868       };
47869     } catch (std::exception& e) {
47870       {
47871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47872       };
47873     } catch (Dali::DaliException e) {
47874       {
47875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47876       };
47877     } catch (...) {
47878       {
47879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47880       };
47881     }
47882   }
47883
47884   jresult = (void *)result;
47885   return jresult;
47886 }
47887
47888
47889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47890   void * jresult ;
47891   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47892   Dali::Rect< int > result;
47893
47894   arg1 = (Dali::NinePatchImage *)jarg1;
47895   {
47896     try {
47897       result = (arg1)->GetChildRectangle();
47898     } catch (std::out_of_range& e) {
47899       {
47900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47901       };
47902     } catch (std::exception& e) {
47903       {
47904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47905       };
47906     } catch (Dali::DaliException e) {
47907       {
47908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47909       };
47910     } catch (...) {
47911       {
47912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47913       };
47914     }
47915   }
47916
47917   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47918   return jresult;
47919 }
47920
47921
47922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47923   void * jresult ;
47924   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47925   Dali::BufferImage result;
47926
47927   arg1 = (Dali::NinePatchImage *)jarg1;
47928   {
47929     try {
47930       result = (arg1)->CreateCroppedBufferImage();
47931     } catch (std::out_of_range& e) {
47932       {
47933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47934       };
47935     } catch (std::exception& e) {
47936       {
47937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47938       };
47939     } catch (Dali::DaliException e) {
47940       {
47941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47942       };
47943     } catch (...) {
47944       {
47945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47946       };
47947     }
47948   }
47949
47950   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47951   return jresult;
47952 }
47953
47954
47955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47956   unsigned int jresult ;
47957   std::string *arg1 = 0 ;
47958   bool result;
47959
47960   if (!jarg1) {
47961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47962     return 0;
47963   }
47964   std::string arg1_str(jarg1);
47965   arg1 = &arg1_str;
47966   {
47967     try {
47968       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47969     } catch (std::out_of_range& e) {
47970       {
47971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47972       };
47973     } catch (std::exception& e) {
47974       {
47975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47976       };
47977     } catch (Dali::DaliException e) {
47978       {
47979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47980       };
47981     } catch (...) {
47982       {
47983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47984       };
47985     }
47986   }
47987
47988   jresult = result;
47989
47990   //argout typemap for const std::string&
47991
47992   return jresult;
47993 }
47994
47995
47996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47997   int jresult ;
47998   int result;
47999
48000   result = (int)Dali::CameraActor::Property::TYPE;
48001   jresult = (int)result;
48002   return jresult;
48003 }
48004
48005
48006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
48007   int jresult ;
48008   int result;
48009
48010   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
48011   jresult = (int)result;
48012   return jresult;
48013 }
48014
48015
48016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
48017   int jresult ;
48018   int result;
48019
48020   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
48021   jresult = (int)result;
48022   return jresult;
48023 }
48024
48025
48026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
48027   int jresult ;
48028   int result;
48029
48030   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
48031   jresult = (int)result;
48032   return jresult;
48033 }
48034
48035
48036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
48037   int jresult ;
48038   int result;
48039
48040   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
48041   jresult = (int)result;
48042   return jresult;
48043 }
48044
48045
48046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
48047   int jresult ;
48048   int result;
48049
48050   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
48051   jresult = (int)result;
48052   return jresult;
48053 }
48054
48055
48056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
48057   int jresult ;
48058   int result;
48059
48060   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
48061   jresult = (int)result;
48062   return jresult;
48063 }
48064
48065
48066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
48067   int jresult ;
48068   int result;
48069
48070   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
48071   jresult = (int)result;
48072   return jresult;
48073 }
48074
48075
48076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
48077   int jresult ;
48078   int result;
48079
48080   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
48081   jresult = (int)result;
48082   return jresult;
48083 }
48084
48085
48086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
48087   int jresult ;
48088   int result;
48089
48090   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48091   jresult = (int)result;
48092   return jresult;
48093 }
48094
48095
48096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48097   int jresult ;
48098   int result;
48099
48100   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48101   jresult = (int)result;
48102   return jresult;
48103 }
48104
48105
48106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48107   int jresult ;
48108   int result;
48109
48110   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48111   jresult = (int)result;
48112   return jresult;
48113 }
48114
48115
48116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48117   int jresult ;
48118   int result;
48119
48120   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48121   jresult = (int)result;
48122   return jresult;
48123 }
48124
48125
48126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48127   int jresult ;
48128   int result;
48129
48130   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48131   jresult = (int)result;
48132   return jresult;
48133 }
48134
48135
48136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48137   void * jresult ;
48138   Dali::CameraActor::Property *result = 0 ;
48139
48140   {
48141     try {
48142       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48143     } catch (std::out_of_range& e) {
48144       {
48145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48146       };
48147     } catch (std::exception& e) {
48148       {
48149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48150       };
48151     } catch (Dali::DaliException e) {
48152       {
48153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48154       };
48155     } catch (...) {
48156       {
48157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48158       };
48159     }
48160   }
48161
48162   jresult = (void *)result;
48163   return jresult;
48164 }
48165
48166
48167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48168   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48169
48170   arg1 = (Dali::CameraActor::Property *)jarg1;
48171   {
48172     try {
48173       delete arg1;
48174     } catch (std::out_of_range& e) {
48175       {
48176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48177       };
48178     } catch (std::exception& e) {
48179       {
48180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48181       };
48182     } catch (Dali::DaliException e) {
48183       {
48184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48185       };
48186     } catch (...) {
48187       {
48188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48189       };
48190     }
48191   }
48192
48193 }
48194
48195
48196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48197   void * jresult ;
48198   Dali::CameraActor *result = 0 ;
48199
48200   {
48201     try {
48202       result = (Dali::CameraActor *)new Dali::CameraActor();
48203     } catch (std::out_of_range& e) {
48204       {
48205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48206       };
48207     } catch (std::exception& e) {
48208       {
48209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48210       };
48211     } catch (Dali::DaliException e) {
48212       {
48213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48214       };
48215     } catch (...) {
48216       {
48217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48218       };
48219     }
48220   }
48221
48222   jresult = (void *)result;
48223   return jresult;
48224 }
48225
48226
48227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48228   void * jresult ;
48229   Dali::CameraActor result;
48230
48231   {
48232     try {
48233       result = Dali::CameraActor::New();
48234     } catch (std::out_of_range& e) {
48235       {
48236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48237       };
48238     } catch (std::exception& e) {
48239       {
48240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48241       };
48242     } catch (Dali::DaliException e) {
48243       {
48244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48245       };
48246     } catch (...) {
48247       {
48248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48249       };
48250     }
48251   }
48252
48253   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48254   return jresult;
48255 }
48256
48257
48258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48259   void * jresult ;
48260   Dali::Size *arg1 = 0 ;
48261   Dali::CameraActor result;
48262
48263   arg1 = (Dali::Size *)jarg1;
48264   if (!arg1) {
48265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48266     return 0;
48267   }
48268   {
48269     try {
48270       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48271     } catch (std::out_of_range& e) {
48272       {
48273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48274       };
48275     } catch (std::exception& e) {
48276       {
48277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48278       };
48279     } catch (Dali::DaliException e) {
48280       {
48281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48282       };
48283     } catch (...) {
48284       {
48285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48286       };
48287     }
48288   }
48289
48290   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48291   return jresult;
48292 }
48293
48294
48295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48296   void * jresult ;
48297   Dali::BaseHandle arg1 ;
48298   Dali::BaseHandle *argp1 ;
48299   Dali::CameraActor result;
48300
48301   argp1 = (Dali::BaseHandle *)jarg1;
48302   if (!argp1) {
48303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48304     return 0;
48305   }
48306   arg1 = *argp1;
48307   {
48308     try {
48309       result = Dali::CameraActor::DownCast(arg1);
48310     } catch (std::out_of_range& e) {
48311       {
48312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48313       };
48314     } catch (std::exception& e) {
48315       {
48316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48317       };
48318     } catch (Dali::DaliException e) {
48319       {
48320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48321       };
48322     } catch (...) {
48323       {
48324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48325       };
48326     }
48327   }
48328
48329   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48330   return jresult;
48331 }
48332
48333
48334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48335   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48336
48337   arg1 = (Dali::CameraActor *)jarg1;
48338   {
48339     try {
48340       delete arg1;
48341     } catch (std::out_of_range& e) {
48342       {
48343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48344       };
48345     } catch (std::exception& e) {
48346       {
48347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48348       };
48349     } catch (Dali::DaliException e) {
48350       {
48351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48352       };
48353     } catch (...) {
48354       {
48355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48356       };
48357     }
48358   }
48359
48360 }
48361
48362
48363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48364   void * jresult ;
48365   Dali::CameraActor *arg1 = 0 ;
48366   Dali::CameraActor *result = 0 ;
48367
48368   arg1 = (Dali::CameraActor *)jarg1;
48369   if (!arg1) {
48370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48371     return 0;
48372   }
48373   {
48374     try {
48375       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48376     } catch (std::out_of_range& e) {
48377       {
48378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48379       };
48380     } catch (std::exception& e) {
48381       {
48382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48383       };
48384     } catch (Dali::DaliException e) {
48385       {
48386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48387       };
48388     } catch (...) {
48389       {
48390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48391       };
48392     }
48393   }
48394
48395   jresult = (void *)result;
48396   return jresult;
48397 }
48398
48399
48400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48401   void * jresult ;
48402   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48403   Dali::CameraActor *arg2 = 0 ;
48404   Dali::CameraActor *result = 0 ;
48405
48406   arg1 = (Dali::CameraActor *)jarg1;
48407   arg2 = (Dali::CameraActor *)jarg2;
48408   if (!arg2) {
48409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48410     return 0;
48411   }
48412   {
48413     try {
48414       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48415     } catch (std::out_of_range& e) {
48416       {
48417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48418       };
48419     } catch (std::exception& e) {
48420       {
48421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48422       };
48423     } catch (Dali::DaliException e) {
48424       {
48425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48426       };
48427     } catch (...) {
48428       {
48429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48430       };
48431     }
48432   }
48433
48434   jresult = (void *)result;
48435   return jresult;
48436 }
48437
48438
48439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48440   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48441   Dali::Camera::Type arg2 ;
48442
48443   arg1 = (Dali::CameraActor *)jarg1;
48444   arg2 = (Dali::Camera::Type)jarg2;
48445   {
48446     try {
48447       (arg1)->SetType(arg2);
48448     } catch (std::out_of_range& e) {
48449       {
48450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48451       };
48452     } catch (std::exception& e) {
48453       {
48454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48455       };
48456     } catch (Dali::DaliException e) {
48457       {
48458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48459       };
48460     } catch (...) {
48461       {
48462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48463       };
48464     }
48465   }
48466
48467 }
48468
48469
48470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48471   int jresult ;
48472   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48473   Dali::Camera::Type result;
48474
48475   arg1 = (Dali::CameraActor *)jarg1;
48476   {
48477     try {
48478       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48479     } catch (std::out_of_range& e) {
48480       {
48481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48482       };
48483     } catch (std::exception& e) {
48484       {
48485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48486       };
48487     } catch (Dali::DaliException e) {
48488       {
48489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48490       };
48491     } catch (...) {
48492       {
48493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48494       };
48495     }
48496   }
48497
48498   jresult = (int)result;
48499   return jresult;
48500 }
48501
48502
48503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48504   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48505   Dali::Camera::ProjectionMode arg2 ;
48506
48507   arg1 = (Dali::CameraActor *)jarg1;
48508   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48509   {
48510     try {
48511       (arg1)->SetProjectionMode(arg2);
48512     } catch (std::out_of_range& e) {
48513       {
48514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48515       };
48516     } catch (std::exception& e) {
48517       {
48518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48519       };
48520     } catch (Dali::DaliException e) {
48521       {
48522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48523       };
48524     } catch (...) {
48525       {
48526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48527       };
48528     }
48529   }
48530
48531 }
48532
48533
48534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48535   int jresult ;
48536   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48537   Dali::Camera::ProjectionMode result;
48538
48539   arg1 = (Dali::CameraActor *)jarg1;
48540   {
48541     try {
48542       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48543     } catch (std::out_of_range& e) {
48544       {
48545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48546       };
48547     } catch (std::exception& e) {
48548       {
48549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48550       };
48551     } catch (Dali::DaliException e) {
48552       {
48553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48554       };
48555     } catch (...) {
48556       {
48557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48558       };
48559     }
48560   }
48561
48562   jresult = (int)result;
48563   return jresult;
48564 }
48565
48566
48567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48568   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48569   float arg2 ;
48570
48571   arg1 = (Dali::CameraActor *)jarg1;
48572   arg2 = (float)jarg2;
48573   {
48574     try {
48575       (arg1)->SetFieldOfView(arg2);
48576     } catch (std::out_of_range& e) {
48577       {
48578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48579       };
48580     } catch (std::exception& e) {
48581       {
48582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48583       };
48584     } catch (Dali::DaliException e) {
48585       {
48586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48587       };
48588     } catch (...) {
48589       {
48590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48591       };
48592     }
48593   }
48594
48595 }
48596
48597
48598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48599   float jresult ;
48600   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48601   float result;
48602
48603   arg1 = (Dali::CameraActor *)jarg1;
48604   {
48605     try {
48606       result = (float)(arg1)->GetFieldOfView();
48607     } catch (std::out_of_range& e) {
48608       {
48609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48610       };
48611     } catch (std::exception& e) {
48612       {
48613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48614       };
48615     } catch (Dali::DaliException e) {
48616       {
48617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48618       };
48619     } catch (...) {
48620       {
48621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48622       };
48623     }
48624   }
48625
48626   jresult = result;
48627   return jresult;
48628 }
48629
48630
48631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48632   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48633   float arg2 ;
48634
48635   arg1 = (Dali::CameraActor *)jarg1;
48636   arg2 = (float)jarg2;
48637   {
48638     try {
48639       (arg1)->SetAspectRatio(arg2);
48640     } catch (std::out_of_range& e) {
48641       {
48642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48643       };
48644     } catch (std::exception& e) {
48645       {
48646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48647       };
48648     } catch (Dali::DaliException e) {
48649       {
48650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48651       };
48652     } catch (...) {
48653       {
48654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48655       };
48656     }
48657   }
48658
48659 }
48660
48661
48662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48663   float jresult ;
48664   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48665   float result;
48666
48667   arg1 = (Dali::CameraActor *)jarg1;
48668   {
48669     try {
48670       result = (float)(arg1)->GetAspectRatio();
48671     } catch (std::out_of_range& e) {
48672       {
48673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48674       };
48675     } catch (std::exception& e) {
48676       {
48677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48678       };
48679     } catch (Dali::DaliException e) {
48680       {
48681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48682       };
48683     } catch (...) {
48684       {
48685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48686       };
48687     }
48688   }
48689
48690   jresult = result;
48691   return jresult;
48692 }
48693
48694
48695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48696   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48697   float arg2 ;
48698
48699   arg1 = (Dali::CameraActor *)jarg1;
48700   arg2 = (float)jarg2;
48701   {
48702     try {
48703       (arg1)->SetNearClippingPlane(arg2);
48704     } catch (std::out_of_range& e) {
48705       {
48706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48707       };
48708     } catch (std::exception& e) {
48709       {
48710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48711       };
48712     } catch (Dali::DaliException e) {
48713       {
48714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48715       };
48716     } catch (...) {
48717       {
48718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48719       };
48720     }
48721   }
48722
48723 }
48724
48725
48726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48727   float jresult ;
48728   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48729   float result;
48730
48731   arg1 = (Dali::CameraActor *)jarg1;
48732   {
48733     try {
48734       result = (float)(arg1)->GetNearClippingPlane();
48735     } catch (std::out_of_range& e) {
48736       {
48737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48738       };
48739     } catch (std::exception& e) {
48740       {
48741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48742       };
48743     } catch (Dali::DaliException e) {
48744       {
48745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48746       };
48747     } catch (...) {
48748       {
48749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48750       };
48751     }
48752   }
48753
48754   jresult = result;
48755   return jresult;
48756 }
48757
48758
48759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48760   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48761   float arg2 ;
48762
48763   arg1 = (Dali::CameraActor *)jarg1;
48764   arg2 = (float)jarg2;
48765   {
48766     try {
48767       (arg1)->SetFarClippingPlane(arg2);
48768     } catch (std::out_of_range& e) {
48769       {
48770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48771       };
48772     } catch (std::exception& e) {
48773       {
48774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48775       };
48776     } catch (Dali::DaliException e) {
48777       {
48778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48779       };
48780     } catch (...) {
48781       {
48782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48783       };
48784     }
48785   }
48786
48787 }
48788
48789
48790 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48791   float jresult ;
48792   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48793   float result;
48794
48795   arg1 = (Dali::CameraActor *)jarg1;
48796   {
48797     try {
48798       result = (float)(arg1)->GetFarClippingPlane();
48799     } catch (std::out_of_range& e) {
48800       {
48801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48802       };
48803     } catch (std::exception& e) {
48804       {
48805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48806       };
48807     } catch (Dali::DaliException e) {
48808       {
48809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48810       };
48811     } catch (...) {
48812       {
48813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48814       };
48815     }
48816   }
48817
48818   jresult = result;
48819   return jresult;
48820 }
48821
48822
48823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48824   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48825   Dali::Vector3 *arg2 = 0 ;
48826
48827   arg1 = (Dali::CameraActor *)jarg1;
48828   arg2 = (Dali::Vector3 *)jarg2;
48829   if (!arg2) {
48830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48831     return ;
48832   }
48833   {
48834     try {
48835       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48836     } catch (std::out_of_range& e) {
48837       {
48838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48839       };
48840     } catch (std::exception& e) {
48841       {
48842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48843       };
48844     } catch (Dali::DaliException e) {
48845       {
48846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48847       };
48848     } catch (...) {
48849       {
48850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48851       };
48852     }
48853   }
48854
48855 }
48856
48857
48858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48859   void * jresult ;
48860   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48861   Dali::Vector3 result;
48862
48863   arg1 = (Dali::CameraActor *)jarg1;
48864   {
48865     try {
48866       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48867     } catch (std::out_of_range& e) {
48868       {
48869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48870       };
48871     } catch (std::exception& e) {
48872       {
48873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48874       };
48875     } catch (Dali::DaliException e) {
48876       {
48877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48878       };
48879     } catch (...) {
48880       {
48881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48882       };
48883     }
48884   }
48885
48886   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48887   return jresult;
48888 }
48889
48890
48891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48892   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48893   bool arg2 ;
48894
48895   arg1 = (Dali::CameraActor *)jarg1;
48896   arg2 = jarg2 ? true : false;
48897   {
48898     try {
48899       (arg1)->SetInvertYAxis(arg2);
48900     } catch (std::out_of_range& e) {
48901       {
48902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48903       };
48904     } catch (std::exception& e) {
48905       {
48906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48907       };
48908     } catch (Dali::DaliException e) {
48909       {
48910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48911       };
48912     } catch (...) {
48913       {
48914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48915       };
48916     }
48917   }
48918
48919 }
48920
48921
48922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48923   unsigned int jresult ;
48924   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48925   bool result;
48926
48927   arg1 = (Dali::CameraActor *)jarg1;
48928   {
48929     try {
48930       result = (bool)(arg1)->GetInvertYAxis();
48931     } catch (std::out_of_range& e) {
48932       {
48933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48934       };
48935     } catch (std::exception& e) {
48936       {
48937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48938       };
48939     } catch (Dali::DaliException e) {
48940       {
48941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48942       };
48943     } catch (...) {
48944       {
48945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48946       };
48947     }
48948   }
48949
48950   jresult = result;
48951   return jresult;
48952 }
48953
48954
48955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48956   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48957   Dali::Size *arg2 = 0 ;
48958
48959   arg1 = (Dali::CameraActor *)jarg1;
48960   arg2 = (Dali::Size *)jarg2;
48961   if (!arg2) {
48962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48963     return ;
48964   }
48965   {
48966     try {
48967       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48968     } catch (std::out_of_range& e) {
48969       {
48970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48971       };
48972     } catch (std::exception& e) {
48973       {
48974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48975       };
48976     } catch (Dali::DaliException e) {
48977       {
48978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48979       };
48980     } catch (...) {
48981       {
48982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48983       };
48984     }
48985   }
48986
48987 }
48988
48989
48990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48991   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48992   Dali::Size *arg2 = 0 ;
48993
48994   arg1 = (Dali::CameraActor *)jarg1;
48995   arg2 = (Dali::Size *)jarg2;
48996   if (!arg2) {
48997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48998     return ;
48999   }
49000   {
49001     try {
49002       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
49003     } catch (std::out_of_range& e) {
49004       {
49005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49006       };
49007     } catch (std::exception& e) {
49008       {
49009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49010       };
49011     } catch (Dali::DaliException e) {
49012       {
49013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49014       };
49015     } catch (...) {
49016       {
49017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49018       };
49019     }
49020   }
49021
49022 }
49023
49024
49025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
49026   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49027   float arg2 ;
49028   float arg3 ;
49029   float arg4 ;
49030   float arg5 ;
49031   float arg6 ;
49032   float arg7 ;
49033
49034   arg1 = (Dali::CameraActor *)jarg1;
49035   arg2 = (float)jarg2;
49036   arg3 = (float)jarg3;
49037   arg4 = (float)jarg4;
49038   arg5 = (float)jarg5;
49039   arg6 = (float)jarg6;
49040   arg7 = (float)jarg7;
49041   {
49042     try {
49043       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
49044     } catch (std::out_of_range& e) {
49045       {
49046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49047       };
49048     } catch (std::exception& e) {
49049       {
49050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49051       };
49052     } catch (Dali::DaliException e) {
49053       {
49054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49055       };
49056     } catch (...) {
49057       {
49058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49059       };
49060     }
49061   }
49062
49063 }
49064
49065
49066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
49067   void * jresult ;
49068   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49069
49070   {
49071     try {
49072       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
49073     } catch (std::out_of_range& e) {
49074       {
49075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49076       };
49077     } catch (std::exception& e) {
49078       {
49079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49080       };
49081     } catch (Dali::DaliException e) {
49082       {
49083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49084       };
49085     } catch (...) {
49086       {
49087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49088       };
49089     }
49090   }
49091
49092   jresult = (void *)result;
49093   return jresult;
49094 }
49095
49096
49097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49098   void * jresult ;
49099   std::string arg1 ;
49100   Dali::Property::Value arg2 ;
49101   Dali::Property::Value *argp2 ;
49102   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49103
49104   if (!jarg1) {
49105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49106     return 0;
49107   }
49108   (&arg1)->assign(jarg1);
49109   argp2 = (Dali::Property::Value *)jarg2;
49110   if (!argp2) {
49111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49112     return 0;
49113   }
49114   arg2 = *argp2;
49115   {
49116     try {
49117       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49118     } catch (std::out_of_range& e) {
49119       {
49120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49121       };
49122     } catch (std::exception& e) {
49123       {
49124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49125       };
49126     } catch (Dali::DaliException e) {
49127       {
49128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49129       };
49130     } catch (...) {
49131       {
49132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49133       };
49134     }
49135   }
49136
49137   jresult = (void *)result;
49138   return jresult;
49139 }
49140
49141
49142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49143   void * jresult ;
49144   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49145   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49146
49147   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49148   if (!arg1) {
49149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49150     return 0;
49151   }
49152   {
49153     try {
49154       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >((std::pair< std::string,Dali::Property::Value > const &)*arg1);
49155     } catch (std::out_of_range& e) {
49156       {
49157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49158       };
49159     } catch (std::exception& e) {
49160       {
49161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49162       };
49163     } catch (Dali::DaliException e) {
49164       {
49165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49166       };
49167     } catch (...) {
49168       {
49169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49170       };
49171     }
49172   }
49173
49174   jresult = (void *)result;
49175   return jresult;
49176 }
49177
49178
49179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49180   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49181   std::string *arg2 = 0 ;
49182
49183   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49184   if (!jarg2) {
49185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49186     return ;
49187   }
49188   std::string arg2_str(jarg2);
49189   arg2 = &arg2_str;
49190   if (arg1) (arg1)->first = *arg2;
49191
49192   //argout typemap for const std::string&
49193
49194 }
49195
49196
49197 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49198   char * jresult ;
49199   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49200   std::string *result = 0 ;
49201
49202   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49203   result = (std::string *) & ((arg1)->first);
49204   jresult = SWIG_csharp_string_callback(result->c_str());
49205   return jresult;
49206 }
49207
49208
49209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49210   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49211   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49212
49213   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49214   arg2 = (Dali::Property::Value *)jarg2;
49215   if (arg1) (arg1)->second = *arg2;
49216 }
49217
49218
49219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49220   void * jresult ;
49221   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49222   Dali::Property::Value *result = 0 ;
49223
49224   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49225   result = (Dali::Property::Value *)& ((arg1)->second);
49226   jresult = (void *)result;
49227   return jresult;
49228 }
49229
49230
49231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49232   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49233
49234   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49235   {
49236     try {
49237       delete arg1;
49238     } catch (std::out_of_range& e) {
49239       {
49240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49241       };
49242     } catch (std::exception& e) {
49243       {
49244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49245       };
49246     } catch (Dali::DaliException e) {
49247       {
49248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49249       };
49250     } catch (...) {
49251       {
49252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49253       };
49254     }
49255   }
49256
49257 }
49258
49259
49260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49261   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49262
49263   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49264   {
49265     try {
49266       (arg1)->clear();
49267     } catch (std::out_of_range& e) {
49268       {
49269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49270       };
49271     } catch (std::exception& e) {
49272       {
49273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49274       };
49275     } catch (Dali::DaliException e) {
49276       {
49277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49278       };
49279     } catch (...) {
49280       {
49281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49282       };
49283     }
49284   }
49285
49286 }
49287
49288
49289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49290   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49291   Dali::TouchPoint *arg2 = 0 ;
49292
49293   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49294   arg2 = (Dali::TouchPoint *)jarg2;
49295   if (!arg2) {
49296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49297     return ;
49298   }
49299   {
49300     try {
49301       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49302     } catch (std::out_of_range& e) {
49303       {
49304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49305       };
49306     } catch (std::exception& e) {
49307       {
49308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49309       };
49310     } catch (Dali::DaliException e) {
49311       {
49312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49313       };
49314     } catch (...) {
49315       {
49316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49317       };
49318     }
49319   }
49320
49321 }
49322
49323
49324 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49325   unsigned long jresult ;
49326   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49327   std::vector< Dali::TouchPoint >::size_type result;
49328
49329   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49330   {
49331     try {
49332       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49333     } catch (std::out_of_range& e) {
49334       {
49335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49336       };
49337     } catch (std::exception& e) {
49338       {
49339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49340       };
49341     } catch (Dali::DaliException e) {
49342       {
49343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49344       };
49345     } catch (...) {
49346       {
49347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49348       };
49349     }
49350   }
49351
49352   jresult = (unsigned long)result;
49353   return jresult;
49354 }
49355
49356
49357 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49358   unsigned long jresult ;
49359   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49360   std::vector< Dali::TouchPoint >::size_type result;
49361
49362   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49363   {
49364     try {
49365       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49366     } catch (std::out_of_range& e) {
49367       {
49368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49369       };
49370     } catch (std::exception& e) {
49371       {
49372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49373       };
49374     } catch (Dali::DaliException e) {
49375       {
49376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49377       };
49378     } catch (...) {
49379       {
49380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49381       };
49382     }
49383   }
49384
49385   jresult = (unsigned long)result;
49386   return jresult;
49387 }
49388
49389
49390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49391   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49392   std::vector< Dali::TouchPoint >::size_type arg2 ;
49393
49394   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49395   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49396   {
49397     try {
49398       (arg1)->reserve(arg2);
49399     } catch (std::out_of_range& e) {
49400       {
49401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49402       };
49403     } catch (std::exception& e) {
49404       {
49405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49406       };
49407     } catch (Dali::DaliException e) {
49408       {
49409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49410       };
49411     } catch (...) {
49412       {
49413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49414       };
49415     }
49416   }
49417
49418 }
49419
49420
49421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49422   void * jresult ;
49423   std::vector< Dali::TouchPoint > *result = 0 ;
49424
49425   {
49426     try {
49427       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49428     } catch (std::out_of_range& e) {
49429       {
49430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49431       };
49432     } catch (std::exception& e) {
49433       {
49434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49435       };
49436     } catch (Dali::DaliException e) {
49437       {
49438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49439       };
49440     } catch (...) {
49441       {
49442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49443       };
49444     }
49445   }
49446
49447   jresult = (void *)result;
49448   return jresult;
49449 }
49450
49451
49452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49453   void * jresult ;
49454   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49455   std::vector< Dali::TouchPoint > *result = 0 ;
49456
49457   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49458   if (!arg1) {
49459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49460     return 0;
49461   }
49462   {
49463     try {
49464       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49465     } catch (std::out_of_range& e) {
49466       {
49467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49468       };
49469     } catch (std::exception& e) {
49470       {
49471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49472       };
49473     } catch (Dali::DaliException e) {
49474       {
49475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49476       };
49477     } catch (...) {
49478       {
49479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49480       };
49481     }
49482   }
49483
49484   jresult = (void *)result;
49485   return jresult;
49486 }
49487
49488
49489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49490   void * jresult ;
49491   int arg1 ;
49492   std::vector< Dali::TouchPoint > *result = 0 ;
49493
49494   arg1 = (int)jarg1;
49495   {
49496     try {
49497       try {
49498         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49499       }
49500       catch(std::out_of_range &_e) {
49501         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49502         return 0;
49503       }
49504
49505     } catch (std::out_of_range& e) {
49506       {
49507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49508       };
49509     } catch (std::exception& e) {
49510       {
49511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49512       };
49513     } catch (Dali::DaliException e) {
49514       {
49515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49516       };
49517     } catch (...) {
49518       {
49519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49520       };
49521     }
49522   }
49523
49524   jresult = (void *)result;
49525   return jresult;
49526 }
49527
49528
49529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49530   void * jresult ;
49531   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49532   int arg2 ;
49533   SwigValueWrapper< Dali::TouchPoint > result;
49534
49535   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49536   arg2 = (int)jarg2;
49537   {
49538     try {
49539       try {
49540         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49541       }
49542       catch(std::out_of_range &_e) {
49543         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49544         return 0;
49545       }
49546
49547     } catch (std::out_of_range& e) {
49548       {
49549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49550       };
49551     } catch (std::exception& e) {
49552       {
49553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49554       };
49555     } catch (Dali::DaliException e) {
49556       {
49557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49558       };
49559     } catch (...) {
49560       {
49561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49562       };
49563     }
49564   }
49565
49566   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49567   return jresult;
49568 }
49569
49570
49571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49572   void * jresult ;
49573   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49574   int arg2 ;
49575   Dali::TouchPoint *result = 0 ;
49576
49577   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49578   arg2 = (int)jarg2;
49579   {
49580     try {
49581       try {
49582         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49583       }
49584       catch(std::out_of_range &_e) {
49585         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49586         return 0;
49587       }
49588
49589     } catch (std::out_of_range& e) {
49590       {
49591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49592       };
49593     } catch (std::exception& e) {
49594       {
49595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49596       };
49597     } catch (Dali::DaliException e) {
49598       {
49599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49600       };
49601     } catch (...) {
49602       {
49603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49604       };
49605     }
49606   }
49607
49608   jresult = (void *)result;
49609   return jresult;
49610 }
49611
49612
49613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49614   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49615   int arg2 ;
49616   Dali::TouchPoint *arg3 = 0 ;
49617
49618   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49619   arg2 = (int)jarg2;
49620   arg3 = (Dali::TouchPoint *)jarg3;
49621   if (!arg3) {
49622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49623     return ;
49624   }
49625   {
49626     try {
49627       try {
49628         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49629       }
49630       catch(std::out_of_range &_e) {
49631         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49632         return ;
49633       }
49634
49635     } catch (std::out_of_range& e) {
49636       {
49637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49638       };
49639     } catch (std::exception& e) {
49640       {
49641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49642       };
49643     } catch (Dali::DaliException e) {
49644       {
49645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49646       };
49647     } catch (...) {
49648       {
49649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49650       };
49651     }
49652   }
49653
49654 }
49655
49656
49657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49658   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49659   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49660
49661   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49662   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49663   if (!arg2) {
49664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49665     return ;
49666   }
49667   {
49668     try {
49669       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49670     } catch (std::out_of_range& e) {
49671       {
49672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49673       };
49674     } catch (std::exception& e) {
49675       {
49676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49677       };
49678     } catch (Dali::DaliException e) {
49679       {
49680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49681       };
49682     } catch (...) {
49683       {
49684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49685       };
49686     }
49687   }
49688
49689 }
49690
49691
49692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49693   void * jresult ;
49694   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49695   int arg2 ;
49696   int arg3 ;
49697   std::vector< Dali::TouchPoint > *result = 0 ;
49698
49699   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49700   arg2 = (int)jarg2;
49701   arg3 = (int)jarg3;
49702   {
49703     try {
49704       try {
49705         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49706       }
49707       catch(std::out_of_range &_e) {
49708         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49709         return 0;
49710       }
49711       catch(std::invalid_argument &_e) {
49712         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49713         return 0;
49714       }
49715
49716     } catch (std::out_of_range& e) {
49717       {
49718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49719       };
49720     } catch (std::exception& e) {
49721       {
49722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49723       };
49724     } catch (Dali::DaliException e) {
49725       {
49726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49727       };
49728     } catch (...) {
49729       {
49730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49731       };
49732     }
49733   }
49734
49735   jresult = (void *)result;
49736   return jresult;
49737 }
49738
49739
49740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49741   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49742   int arg2 ;
49743   Dali::TouchPoint *arg3 = 0 ;
49744
49745   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49746   arg2 = (int)jarg2;
49747   arg3 = (Dali::TouchPoint *)jarg3;
49748   if (!arg3) {
49749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49750     return ;
49751   }
49752   {
49753     try {
49754       try {
49755         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49756       }
49757       catch(std::out_of_range &_e) {
49758         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49759         return ;
49760       }
49761
49762     } catch (std::out_of_range& e) {
49763       {
49764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49765       };
49766     } catch (std::exception& e) {
49767       {
49768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49769       };
49770     } catch (Dali::DaliException e) {
49771       {
49772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49773       };
49774     } catch (...) {
49775       {
49776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49777       };
49778     }
49779   }
49780
49781 }
49782
49783
49784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49785   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49786   int arg2 ;
49787   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49788
49789   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49790   arg2 = (int)jarg2;
49791   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49792   if (!arg3) {
49793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49794     return ;
49795   }
49796   {
49797     try {
49798       try {
49799         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49800       }
49801       catch(std::out_of_range &_e) {
49802         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49803         return ;
49804       }
49805
49806     } catch (std::out_of_range& e) {
49807       {
49808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49809       };
49810     } catch (std::exception& e) {
49811       {
49812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49813       };
49814     } catch (Dali::DaliException e) {
49815       {
49816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49817       };
49818     } catch (...) {
49819       {
49820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49821       };
49822     }
49823   }
49824
49825 }
49826
49827
49828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49829   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49830   int arg2 ;
49831
49832   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49833   arg2 = (int)jarg2;
49834   {
49835     try {
49836       try {
49837         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49838       }
49839       catch(std::out_of_range &_e) {
49840         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49841         return ;
49842       }
49843
49844     } catch (std::out_of_range& e) {
49845       {
49846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49847       };
49848     } catch (std::exception& e) {
49849       {
49850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49851       };
49852     } catch (Dali::DaliException e) {
49853       {
49854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49855       };
49856     } catch (...) {
49857       {
49858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49859       };
49860     }
49861   }
49862
49863 }
49864
49865
49866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49867   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49868   int arg2 ;
49869   int arg3 ;
49870
49871   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49872   arg2 = (int)jarg2;
49873   arg3 = (int)jarg3;
49874   {
49875     try {
49876       try {
49877         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49878       }
49879       catch(std::out_of_range &_e) {
49880         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49881         return ;
49882       }
49883       catch(std::invalid_argument &_e) {
49884         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49885         return ;
49886       }
49887
49888     } catch (std::out_of_range& e) {
49889       {
49890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49891       };
49892     } catch (std::exception& e) {
49893       {
49894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49895       };
49896     } catch (Dali::DaliException e) {
49897       {
49898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49899       };
49900     } catch (...) {
49901       {
49902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49903       };
49904     }
49905   }
49906
49907 }
49908
49909
49910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49911   void * jresult ;
49912   Dali::TouchPoint *arg1 = 0 ;
49913   int arg2 ;
49914   std::vector< Dali::TouchPoint > *result = 0 ;
49915
49916   arg1 = (Dali::TouchPoint *)jarg1;
49917   if (!arg1) {
49918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49919     return 0;
49920   }
49921   arg2 = (int)jarg2;
49922   {
49923     try {
49924       try {
49925         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49926       }
49927       catch(std::out_of_range &_e) {
49928         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49929         return 0;
49930       }
49931
49932     } catch (std::out_of_range& e) {
49933       {
49934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49935       };
49936     } catch (std::exception& e) {
49937       {
49938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49939       };
49940     } catch (Dali::DaliException e) {
49941       {
49942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49943       };
49944     } catch (...) {
49945       {
49946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49947       };
49948     }
49949   }
49950
49951   jresult = (void *)result;
49952   return jresult;
49953 }
49954
49955
49956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49957   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49958
49959   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49960   {
49961     try {
49962       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49963     } catch (std::out_of_range& e) {
49964       {
49965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49966       };
49967     } catch (std::exception& e) {
49968       {
49969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49970       };
49971     } catch (Dali::DaliException e) {
49972       {
49973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49974       };
49975     } catch (...) {
49976       {
49977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49978       };
49979     }
49980   }
49981
49982 }
49983
49984
49985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49986   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49987   int arg2 ;
49988   int arg3 ;
49989
49990   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49991   arg2 = (int)jarg2;
49992   arg3 = (int)jarg3;
49993   {
49994     try {
49995       try {
49996         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49997       }
49998       catch(std::out_of_range &_e) {
49999         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50000         return ;
50001       }
50002       catch(std::invalid_argument &_e) {
50003         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
50004         return ;
50005       }
50006
50007     } catch (std::out_of_range& e) {
50008       {
50009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50010       };
50011     } catch (std::exception& e) {
50012       {
50013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50014       };
50015     } catch (Dali::DaliException e) {
50016       {
50017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50018       };
50019     } catch (...) {
50020       {
50021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50022       };
50023     }
50024   }
50025
50026 }
50027
50028
50029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
50030   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50031   int arg2 ;
50032   std::vector< Dali::TouchPoint > *arg3 = 0 ;
50033
50034   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50035   arg2 = (int)jarg2;
50036   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
50037   if (!arg3) {
50038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
50039     return ;
50040   }
50041   {
50042     try {
50043       try {
50044         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
50045       }
50046       catch(std::out_of_range &_e) {
50047         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50048         return ;
50049       }
50050
50051     } catch (std::out_of_range& e) {
50052       {
50053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50054       };
50055     } catch (std::exception& e) {
50056       {
50057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50058       };
50059     } catch (Dali::DaliException e) {
50060       {
50061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50062       };
50063     } catch (...) {
50064       {
50065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50066       };
50067     }
50068   }
50069
50070 }
50071
50072
50073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
50074   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50075
50076   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50077   {
50078     try {
50079       delete arg1;
50080     } catch (std::out_of_range& e) {
50081       {
50082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50083       };
50084     } catch (std::exception& e) {
50085       {
50086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50087       };
50088     } catch (Dali::DaliException e) {
50089       {
50090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50091       };
50092     } catch (...) {
50093       {
50094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50095       };
50096     }
50097   }
50098
50099 }
50100
50101
50102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50103   void * jresult ;
50104   Dali::Rect< int > *result = 0 ;
50105
50106   {
50107     try {
50108       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50109     } catch (std::out_of_range& e) {
50110       {
50111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50112       };
50113     } catch (std::exception& e) {
50114       {
50115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50116       };
50117     } catch (Dali::DaliException e) {
50118       {
50119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50120       };
50121     } catch (...) {
50122       {
50123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50124       };
50125     }
50126   }
50127
50128   jresult = (void *)result;
50129   return jresult;
50130 }
50131
50132
50133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50134   void * jresult ;
50135   int arg1 ;
50136   int arg2 ;
50137   int arg3 ;
50138   int arg4 ;
50139   Dali::Rect< int > *result = 0 ;
50140
50141   arg1 = (int)jarg1;
50142   arg2 = (int)jarg2;
50143   arg3 = (int)jarg3;
50144   arg4 = (int)jarg4;
50145   {
50146     try {
50147       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50148     } catch (std::out_of_range& e) {
50149       {
50150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50151       };
50152     } catch (std::exception& e) {
50153       {
50154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50155       };
50156     } catch (Dali::DaliException e) {
50157       {
50158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50159       };
50160     } catch (...) {
50161       {
50162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50163       };
50164     }
50165   }
50166
50167   jresult = (void *)result;
50168   return jresult;
50169 }
50170
50171
50172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50173   void * jresult ;
50174   Dali::Rect< int > *arg1 = 0 ;
50175   Dali::Rect< int > *result = 0 ;
50176
50177   arg1 = (Dali::Rect< int > *)jarg1;
50178   if (!arg1) {
50179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50180     return 0;
50181   }
50182   {
50183     try {
50184       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50185     } catch (std::out_of_range& e) {
50186       {
50187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50188       };
50189     } catch (std::exception& e) {
50190       {
50191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50192       };
50193     } catch (Dali::DaliException e) {
50194       {
50195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50196       };
50197     } catch (...) {
50198       {
50199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50200       };
50201     }
50202   }
50203
50204   jresult = (void *)result;
50205   return jresult;
50206 }
50207
50208
50209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50210   void * jresult ;
50211   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50212   Dali::Rect< int > *arg2 = 0 ;
50213   Dali::Rect< int > *result = 0 ;
50214
50215   arg1 = (Dali::Rect< int > *)jarg1;
50216   arg2 = (Dali::Rect< int > *)jarg2;
50217   if (!arg2) {
50218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50219     return 0;
50220   }
50221   {
50222     try {
50223       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50224     } catch (std::out_of_range& e) {
50225       {
50226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50227       };
50228     } catch (std::exception& e) {
50229       {
50230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50231       };
50232     } catch (Dali::DaliException e) {
50233       {
50234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50235       };
50236     } catch (...) {
50237       {
50238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50239       };
50240     }
50241   }
50242
50243   jresult = (void *)result;
50244   return jresult;
50245 }
50246
50247
50248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50249   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50250   int arg2 ;
50251   int arg3 ;
50252   int arg4 ;
50253   int arg5 ;
50254
50255   arg1 = (Dali::Rect< int > *)jarg1;
50256   arg2 = (int)jarg2;
50257   arg3 = (int)jarg3;
50258   arg4 = (int)jarg4;
50259   arg5 = (int)jarg5;
50260   {
50261     try {
50262       (arg1)->Set(arg2,arg3,arg4,arg5);
50263     } catch (std::out_of_range& e) {
50264       {
50265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50266       };
50267     } catch (std::exception& e) {
50268       {
50269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50270       };
50271     } catch (Dali::DaliException e) {
50272       {
50273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50274       };
50275     } catch (...) {
50276       {
50277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50278       };
50279     }
50280   }
50281
50282 }
50283
50284
50285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50286   unsigned int jresult ;
50287   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50288   bool result;
50289
50290   arg1 = (Dali::Rect< int > *)jarg1;
50291   {
50292     try {
50293       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50294     } catch (std::out_of_range& e) {
50295       {
50296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50297       };
50298     } catch (std::exception& e) {
50299       {
50300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50301       };
50302     } catch (Dali::DaliException e) {
50303       {
50304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50305       };
50306     } catch (...) {
50307       {
50308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50309       };
50310     }
50311   }
50312
50313   jresult = result;
50314   return jresult;
50315 }
50316
50317
50318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50319   int jresult ;
50320   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50321   int result;
50322
50323   arg1 = (Dali::Rect< int > *)jarg1;
50324   {
50325     try {
50326       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50327     } catch (std::out_of_range& e) {
50328       {
50329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50330       };
50331     } catch (std::exception& e) {
50332       {
50333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50334       };
50335     } catch (Dali::DaliException e) {
50336       {
50337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50338       };
50339     } catch (...) {
50340       {
50341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50342       };
50343     }
50344   }
50345
50346   jresult = result;
50347   return jresult;
50348 }
50349
50350
50351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50352   int jresult ;
50353   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50354   int result;
50355
50356   arg1 = (Dali::Rect< int > *)jarg1;
50357   {
50358     try {
50359       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50360     } catch (std::out_of_range& e) {
50361       {
50362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50363       };
50364     } catch (std::exception& e) {
50365       {
50366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50367       };
50368     } catch (Dali::DaliException e) {
50369       {
50370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50371       };
50372     } catch (...) {
50373       {
50374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50375       };
50376     }
50377   }
50378
50379   jresult = result;
50380   return jresult;
50381 }
50382
50383
50384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50385   int jresult ;
50386   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50387   int result;
50388
50389   arg1 = (Dali::Rect< int > *)jarg1;
50390   {
50391     try {
50392       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50393     } catch (std::out_of_range& e) {
50394       {
50395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50396       };
50397     } catch (std::exception& e) {
50398       {
50399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50400       };
50401     } catch (Dali::DaliException e) {
50402       {
50403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50404       };
50405     } catch (...) {
50406       {
50407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50408       };
50409     }
50410   }
50411
50412   jresult = result;
50413   return jresult;
50414 }
50415
50416
50417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50418   int jresult ;
50419   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50420   int result;
50421
50422   arg1 = (Dali::Rect< int > *)jarg1;
50423   {
50424     try {
50425       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50426     } catch (std::out_of_range& e) {
50427       {
50428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50429       };
50430     } catch (std::exception& e) {
50431       {
50432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50433       };
50434     } catch (Dali::DaliException e) {
50435       {
50436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50437       };
50438     } catch (...) {
50439       {
50440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50441       };
50442     }
50443   }
50444
50445   jresult = result;
50446   return jresult;
50447 }
50448
50449
50450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50451   int jresult ;
50452   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50453   int result;
50454
50455   arg1 = (Dali::Rect< int > *)jarg1;
50456   {
50457     try {
50458       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50459     } catch (std::out_of_range& e) {
50460       {
50461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50462       };
50463     } catch (std::exception& e) {
50464       {
50465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50466       };
50467     } catch (Dali::DaliException e) {
50468       {
50469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50470       };
50471     } catch (...) {
50472       {
50473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50474       };
50475     }
50476   }
50477
50478   jresult = result;
50479   return jresult;
50480 }
50481
50482
50483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50484   unsigned int jresult ;
50485   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50486   Dali::Rect< int > *arg2 = 0 ;
50487   bool result;
50488
50489   arg1 = (Dali::Rect< int > *)jarg1;
50490   arg2 = (Dali::Rect< int > *)jarg2;
50491   if (!arg2) {
50492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50493     return 0;
50494   }
50495   {
50496     try {
50497       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50498     } catch (std::out_of_range& e) {
50499       {
50500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50501       };
50502     } catch (std::exception& e) {
50503       {
50504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50505       };
50506     } catch (Dali::DaliException e) {
50507       {
50508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50509       };
50510     } catch (...) {
50511       {
50512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50513       };
50514     }
50515   }
50516
50517   jresult = result;
50518   return jresult;
50519 }
50520
50521
50522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50523   unsigned int jresult ;
50524   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50525   Dali::Rect< int > *arg2 = 0 ;
50526   bool result;
50527
50528   arg1 = (Dali::Rect< int > *)jarg1;
50529   arg2 = (Dali::Rect< int > *)jarg2;
50530   if (!arg2) {
50531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50532     return 0;
50533   }
50534   {
50535     try {
50536       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50537     } catch (std::out_of_range& e) {
50538       {
50539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50540       };
50541     } catch (std::exception& e) {
50542       {
50543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50544       };
50545     } catch (Dali::DaliException e) {
50546       {
50547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50548       };
50549     } catch (...) {
50550       {
50551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50552       };
50553     }
50554   }
50555
50556   jresult = result;
50557   return jresult;
50558 }
50559
50560
50561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50562   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50563   int arg2 ;
50564
50565   arg1 = (Dali::Rect< int > *)jarg1;
50566   arg2 = (int)jarg2;
50567   if (arg1) (arg1)->x = arg2;
50568 }
50569
50570
50571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50572   int jresult ;
50573   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50574   int result;
50575
50576   arg1 = (Dali::Rect< int > *)jarg1;
50577   result = (int) ((arg1)->x);
50578   jresult = result;
50579   return jresult;
50580 }
50581
50582
50583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50584   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50585   int arg2 ;
50586
50587   arg1 = (Dali::Rect< int > *)jarg1;
50588   arg2 = (int)jarg2;
50589   if (arg1) (arg1)->left = arg2;
50590 }
50591
50592
50593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50594   int jresult ;
50595   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50596   int result;
50597
50598   arg1 = (Dali::Rect< int > *)jarg1;
50599   result = (int) ((arg1)->left);
50600   jresult = result;
50601   return jresult;
50602 }
50603
50604
50605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50606   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50607   int arg2 ;
50608
50609   arg1 = (Dali::Rect< int > *)jarg1;
50610   arg2 = (int)jarg2;
50611   if (arg1) (arg1)->y = arg2;
50612 }
50613
50614
50615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50616   int jresult ;
50617   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50618   int result;
50619
50620   arg1 = (Dali::Rect< int > *)jarg1;
50621   result = (int) ((arg1)->y);
50622   jresult = result;
50623   return jresult;
50624 }
50625
50626
50627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50628   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50629   int arg2 ;
50630
50631   arg1 = (Dali::Rect< int > *)jarg1;
50632   arg2 = (int)jarg2;
50633   if (arg1) (arg1)->right = arg2;
50634 }
50635
50636
50637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50638   int jresult ;
50639   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50640   int result;
50641
50642   arg1 = (Dali::Rect< int > *)jarg1;
50643   result = (int) ((arg1)->right);
50644   jresult = result;
50645   return jresult;
50646 }
50647
50648
50649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50650   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50651   int arg2 ;
50652
50653   arg1 = (Dali::Rect< int > *)jarg1;
50654   arg2 = (int)jarg2;
50655   if (arg1) (arg1)->width = arg2;
50656 }
50657
50658
50659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50660   int jresult ;
50661   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50662   int result;
50663
50664   arg1 = (Dali::Rect< int > *)jarg1;
50665   result = (int) ((arg1)->width);
50666   jresult = result;
50667   return jresult;
50668 }
50669
50670
50671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50672   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50673   int arg2 ;
50674
50675   arg1 = (Dali::Rect< int > *)jarg1;
50676   arg2 = (int)jarg2;
50677   if (arg1) (arg1)->bottom = arg2;
50678 }
50679
50680
50681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50682   int jresult ;
50683   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50684   int result;
50685
50686   arg1 = (Dali::Rect< int > *)jarg1;
50687   result = (int) ((arg1)->bottom);
50688   jresult = result;
50689   return jresult;
50690 }
50691
50692
50693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50694   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50695   int arg2 ;
50696
50697   arg1 = (Dali::Rect< int > *)jarg1;
50698   arg2 = (int)jarg2;
50699   if (arg1) (arg1)->height = arg2;
50700 }
50701
50702
50703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50704   int jresult ;
50705   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50706   int result;
50707
50708   arg1 = (Dali::Rect< int > *)jarg1;
50709   result = (int) ((arg1)->height);
50710   jresult = result;
50711   return jresult;
50712 }
50713
50714
50715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50716   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50717   int arg2 ;
50718
50719   arg1 = (Dali::Rect< int > *)jarg1;
50720   arg2 = (int)jarg2;
50721   if (arg1) (arg1)->top = arg2;
50722 }
50723
50724
50725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50726   int jresult ;
50727   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50728   int result;
50729
50730   arg1 = (Dali::Rect< int > *)jarg1;
50731   result = (int) ((arg1)->top);
50732   jresult = result;
50733   return jresult;
50734 }
50735
50736
50737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50738   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50739
50740   arg1 = (Dali::Rect< int > *)jarg1;
50741   {
50742     try {
50743       delete arg1;
50744     } catch (std::out_of_range& e) {
50745       {
50746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50747       };
50748     } catch (std::exception& e) {
50749       {
50750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50751       };
50752     } catch (Dali::DaliException e) {
50753       {
50754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50755       };
50756     } catch (...) {
50757       {
50758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50759       };
50760     }
50761   }
50762
50763 }
50764
50765
50766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50767   void * jresult ;
50768   Dali::Rect< float > *result = 0 ;
50769
50770   {
50771     try {
50772       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50773     } catch (std::out_of_range& e) {
50774       {
50775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50776       };
50777     } catch (std::exception& e) {
50778       {
50779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50780       };
50781     } catch (Dali::DaliException e) {
50782       {
50783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50784       };
50785     } catch (...) {
50786       {
50787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50788       };
50789     }
50790   }
50791
50792   jresult = (void *)result;
50793   return jresult;
50794 }
50795
50796
50797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50798   void * jresult ;
50799   float arg1 ;
50800   float arg2 ;
50801   float arg3 ;
50802   float arg4 ;
50803   Dali::Rect< float > *result = 0 ;
50804
50805   arg1 = (float)jarg1;
50806   arg2 = (float)jarg2;
50807   arg3 = (float)jarg4;
50808   arg4 = (float)jarg3;
50809   {
50810     try {
50811       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50812     } catch (std::out_of_range& e) {
50813       {
50814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50815       };
50816     } catch (std::exception& e) {
50817       {
50818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50819       };
50820     } catch (Dali::DaliException e) {
50821       {
50822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50823       };
50824     } catch (...) {
50825       {
50826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50827       };
50828     }
50829   }
50830
50831   jresult = (void *)result;
50832   return jresult;
50833 }
50834
50835
50836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50837   void * jresult ;
50838   Dali::Rect< float > *arg1 = 0 ;
50839   Dali::Rect< float > *result = 0 ;
50840
50841   arg1 = (Dali::Rect< float > *)jarg1;
50842   if (!arg1) {
50843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50844     return 0;
50845   }
50846   {
50847     try {
50848       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50849     } catch (std::out_of_range& e) {
50850       {
50851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50852       };
50853     } catch (std::exception& e) {
50854       {
50855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50856       };
50857     } catch (Dali::DaliException e) {
50858       {
50859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50860       };
50861     } catch (...) {
50862       {
50863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50864       };
50865     }
50866   }
50867
50868   jresult = (void *)result;
50869   return jresult;
50870 }
50871
50872
50873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50874   void * jresult ;
50875   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50876   Dali::Rect< float > *arg2 = 0 ;
50877   Dali::Rect< float > *result = 0 ;
50878
50879   arg1 = (Dali::Rect< float > *)jarg1;
50880   arg2 = (Dali::Rect< float > *)jarg2;
50881   if (!arg2) {
50882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50883     return 0;
50884   }
50885   {
50886     try {
50887       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50888     } catch (std::out_of_range& e) {
50889       {
50890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50891       };
50892     } catch (std::exception& e) {
50893       {
50894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50895       };
50896     } catch (Dali::DaliException e) {
50897       {
50898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50899       };
50900     } catch (...) {
50901       {
50902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50903       };
50904     }
50905   }
50906
50907   jresult = (void *)result;
50908   return jresult;
50909 }
50910
50911
50912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50913   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50914   float arg2 ;
50915   float arg3 ;
50916   float arg4 ;
50917   float arg5 ;
50918
50919   arg1 = (Dali::Rect< float > *)jarg1;
50920   arg2 = (float)jarg2;
50921   arg3 = (float)jarg3;
50922   arg4 = (float)jarg5;
50923   arg5 = (float)jarg4;
50924   {
50925     try {
50926       (arg1)->Set(arg2,arg3,arg4,arg5);
50927     } catch (std::out_of_range& e) {
50928       {
50929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50930       };
50931     } catch (std::exception& e) {
50932       {
50933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50934       };
50935     } catch (Dali::DaliException e) {
50936       {
50937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50938       };
50939     } catch (...) {
50940       {
50941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50942       };
50943     }
50944   }
50945
50946 }
50947
50948
50949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50950   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50951   float arg2 ;
50952
50953   arg1 = (Dali::Rect< float > *)jarg1;
50954   arg2 = (float)jarg2;
50955   if (arg1) (arg1)->left = arg2;
50956 }
50957
50958
50959 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50960   float jresult ;
50961   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50962   float result;
50963
50964   arg1 = (Dali::Rect< float > *)jarg1;
50965   result = (float) ((arg1)->left);
50966   jresult = result;
50967   return jresult;
50968 }
50969
50970
50971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50972   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50973   float arg2 ;
50974
50975   arg1 = (Dali::Rect< float > *)jarg1;
50976   arg2 = (float)jarg2;
50977   if (arg1) (arg1)->left = arg2;
50978 }
50979
50980
50981 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50982   float jresult ;
50983   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50984   float result;
50985
50986   arg1 = (Dali::Rect< float > *)jarg1;
50987   result = (float) ((arg1)->left);
50988   jresult = result;
50989   return jresult;
50990 }
50991
50992
50993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50994   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50995   float arg2 ;
50996
50997   arg1 = (Dali::Rect< float > *)jarg1;
50998   arg2 = (float)jarg2;
50999   if (arg1) (arg1)->right = arg2;
51000 }
51001
51002
51003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
51004   float jresult ;
51005   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51006   float result;
51007
51008   arg1 = (Dali::Rect< float > *)jarg1;
51009   result = (float) ((arg1)->right);
51010   jresult = result;
51011   return jresult;
51012 }
51013
51014
51015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
51016   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51017   float arg2 ;
51018
51019   arg1 = (Dali::Rect< float > *)jarg1;
51020   arg2 = (float)jarg2;
51021   if (arg1) (arg1)->right = arg2;
51022 }
51023
51024
51025 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
51026   float jresult ;
51027   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51028   float result;
51029
51030   arg1 = (Dali::Rect< float > *)jarg1;
51031   result = (float) ((arg1)->right);
51032   jresult = result;
51033   return jresult;
51034 }
51035
51036
51037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
51038   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51039   float arg2 ;
51040
51041   arg1 = (Dali::Rect< float > *)jarg1;
51042   arg2 = (float)jarg2;
51043   if (arg1) (arg1)->bottom = arg2;
51044 }
51045
51046
51047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
51048   float jresult ;
51049   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51050   float result;
51051
51052   arg1 = (Dali::Rect< float > *)jarg1;
51053   result = (float) ((arg1)->bottom);
51054   jresult = result;
51055   return jresult;
51056 }
51057
51058
51059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
51060   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51061   float arg2 ;
51062
51063   arg1 = (Dali::Rect< float > *)jarg1;
51064   arg2 = (float)jarg2;
51065   if (arg1) (arg1)->top = arg2;
51066 }
51067
51068
51069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
51070   float jresult ;
51071   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51072   float result;
51073
51074   arg1 = (Dali::Rect< float > *)jarg1;
51075   result = (float) ((arg1)->top);
51076   jresult = result;
51077   return jresult;
51078 }
51079
51080
51081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
51082   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51083
51084   arg1 = (Dali::Rect< float > *)jarg1;
51085   {
51086     try {
51087       delete arg1;
51088     } catch (std::out_of_range& e) {
51089       {
51090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51091       };
51092     } catch (std::exception& e) {
51093       {
51094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51095       };
51096     } catch (Dali::DaliException e) {
51097       {
51098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51099       };
51100     } catch (...) {
51101       {
51102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51103       };
51104     }
51105   }
51106
51107 }
51108
51109
51110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51111   int jresult ;
51112   int result;
51113
51114   result = (int)Dali::Vector< int >::BaseType;
51115   jresult = (int)result;
51116   return jresult;
51117 }
51118
51119
51120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51121   void * jresult ;
51122   Dali::Vector< int > *result = 0 ;
51123
51124   {
51125     try {
51126       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51127     } catch (std::out_of_range& e) {
51128       {
51129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51130       };
51131     } catch (std::exception& e) {
51132       {
51133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51134       };
51135     } catch (Dali::DaliException e) {
51136       {
51137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51138       };
51139     } catch (...) {
51140       {
51141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51142       };
51143     }
51144   }
51145
51146   jresult = (void *)result;
51147   return jresult;
51148 }
51149
51150
51151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51152   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51153
51154   arg1 = (Dali::Vector< int > *)jarg1;
51155   {
51156     try {
51157       delete arg1;
51158     } catch (std::out_of_range& e) {
51159       {
51160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51161       };
51162     } catch (std::exception& e) {
51163       {
51164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51165       };
51166     } catch (Dali::DaliException e) {
51167       {
51168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51169       };
51170     } catch (...) {
51171       {
51172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51173       };
51174     }
51175   }
51176
51177 }
51178
51179
51180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51181   void * jresult ;
51182   Dali::Vector< int > *arg1 = 0 ;
51183   Dali::Vector< int > *result = 0 ;
51184
51185   arg1 = (Dali::Vector< int > *)jarg1;
51186   if (!arg1) {
51187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51188     return 0;
51189   }
51190   {
51191     try {
51192       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51193     } catch (std::out_of_range& e) {
51194       {
51195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51196       };
51197     } catch (std::exception& e) {
51198       {
51199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51200       };
51201     } catch (Dali::DaliException e) {
51202       {
51203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51204       };
51205     } catch (...) {
51206       {
51207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51208       };
51209     }
51210   }
51211
51212   jresult = (void *)result;
51213   return jresult;
51214 }
51215
51216
51217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51218   void * jresult ;
51219   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51220   Dali::Vector< int > *arg2 = 0 ;
51221   Dali::Vector< int > *result = 0 ;
51222
51223   arg1 = (Dali::Vector< int > *)jarg1;
51224   arg2 = (Dali::Vector< int > *)jarg2;
51225   if (!arg2) {
51226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51227     return 0;
51228   }
51229   {
51230     try {
51231       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51232     } catch (std::out_of_range& e) {
51233       {
51234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51235       };
51236     } catch (std::exception& e) {
51237       {
51238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51239       };
51240     } catch (Dali::DaliException e) {
51241       {
51242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51243       };
51244     } catch (...) {
51245       {
51246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51247       };
51248     }
51249   }
51250
51251   jresult = (void *)result;
51252   return jresult;
51253 }
51254
51255
51256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51257   void * jresult ;
51258   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51259   Dali::Vector< int >::Iterator result;
51260
51261   arg1 = (Dali::Vector< int > *)jarg1;
51262   {
51263     try {
51264       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51265     } catch (std::out_of_range& e) {
51266       {
51267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51268       };
51269     } catch (std::exception& e) {
51270       {
51271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51272       };
51273     } catch (Dali::DaliException e) {
51274       {
51275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51276       };
51277     } catch (...) {
51278       {
51279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51280       };
51281     }
51282   }
51283
51284   jresult = (void *)result;
51285   return jresult;
51286 }
51287
51288
51289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51290   void * jresult ;
51291   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51292   Dali::Vector< int >::Iterator result;
51293
51294   arg1 = (Dali::Vector< int > *)jarg1;
51295   {
51296     try {
51297       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51298     } catch (std::out_of_range& e) {
51299       {
51300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51301       };
51302     } catch (std::exception& e) {
51303       {
51304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51305       };
51306     } catch (Dali::DaliException e) {
51307       {
51308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51309       };
51310     } catch (...) {
51311       {
51312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51313       };
51314     }
51315   }
51316
51317   jresult = (void *)result;
51318   return jresult;
51319 }
51320
51321
51322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51323   void * jresult ;
51324   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51325   Dali::Vector< int >::SizeType arg2 ;
51326   Dali::Vector< int >::ItemType *result = 0 ;
51327
51328   arg1 = (Dali::Vector< int > *)jarg1;
51329   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51330   {
51331     try {
51332       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51333     } catch (std::out_of_range& e) {
51334       {
51335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51336       };
51337     } catch (std::exception& e) {
51338       {
51339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51340       };
51341     } catch (Dali::DaliException e) {
51342       {
51343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51344       };
51345     } catch (...) {
51346       {
51347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51348       };
51349     }
51350   }
51351
51352   jresult = (void *)result;
51353   return jresult;
51354 }
51355
51356
51357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51358   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51359   Dali::Vector< int >::ItemType *arg2 = 0 ;
51360   Dali::Vector< int >::ItemType temp2 ;
51361
51362   arg1 = (Dali::Vector< int > *)jarg1;
51363   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51364   arg2 = &temp2;
51365   {
51366     try {
51367       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51368     } catch (std::out_of_range& e) {
51369       {
51370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51371       };
51372     } catch (std::exception& e) {
51373       {
51374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51375       };
51376     } catch (Dali::DaliException e) {
51377       {
51378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51379       };
51380     } catch (...) {
51381       {
51382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51383       };
51384     }
51385   }
51386
51387 }
51388
51389
51390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51391   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51392   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51393   Dali::Vector< int >::ItemType *arg3 = 0 ;
51394   Dali::Vector< int >::ItemType temp3 ;
51395
51396   arg1 = (Dali::Vector< int > *)jarg1;
51397   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51398   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51399   arg3 = &temp3;
51400   {
51401     try {
51402       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51403     } catch (std::out_of_range& e) {
51404       {
51405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51406       };
51407     } catch (std::exception& e) {
51408       {
51409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51410       };
51411     } catch (Dali::DaliException e) {
51412       {
51413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51414       };
51415     } catch (...) {
51416       {
51417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51418       };
51419     }
51420   }
51421
51422 }
51423
51424
51425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51426   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51427   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51428   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51429   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51430
51431   arg1 = (Dali::Vector< int > *)jarg1;
51432   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51433   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51434   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51435   {
51436     try {
51437       (arg1)->Insert(arg2,arg3,arg4);
51438     } catch (std::out_of_range& e) {
51439       {
51440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51441       };
51442     } catch (std::exception& e) {
51443       {
51444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51445       };
51446     } catch (Dali::DaliException e) {
51447       {
51448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51449       };
51450     } catch (...) {
51451       {
51452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51453       };
51454     }
51455   }
51456
51457 }
51458
51459
51460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51461   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51462   Dali::Vector< int >::SizeType arg2 ;
51463
51464   arg1 = (Dali::Vector< int > *)jarg1;
51465   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51466   {
51467     try {
51468       (arg1)->Reserve(arg2);
51469     } catch (std::out_of_range& e) {
51470       {
51471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51472       };
51473     } catch (std::exception& e) {
51474       {
51475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51476       };
51477     } catch (Dali::DaliException e) {
51478       {
51479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51480       };
51481     } catch (...) {
51482       {
51483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51484       };
51485     }
51486   }
51487
51488 }
51489
51490
51491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51492   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51493   Dali::Vector< int >::SizeType arg2 ;
51494
51495   arg1 = (Dali::Vector< int > *)jarg1;
51496   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51497   {
51498     try {
51499       (arg1)->Resize(arg2);
51500     } catch (std::out_of_range& e) {
51501       {
51502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51503       };
51504     } catch (std::exception& e) {
51505       {
51506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51507       };
51508     } catch (Dali::DaliException e) {
51509       {
51510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51511       };
51512     } catch (...) {
51513       {
51514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51515       };
51516     }
51517   }
51518
51519 }
51520
51521
51522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51523   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51524   Dali::Vector< int >::SizeType arg2 ;
51525   Dali::Vector< int >::ItemType *arg3 = 0 ;
51526   Dali::Vector< int >::ItemType temp3 ;
51527
51528   arg1 = (Dali::Vector< int > *)jarg1;
51529   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51530   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51531   arg3 = &temp3;
51532   {
51533     try {
51534       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51535     } catch (std::out_of_range& e) {
51536       {
51537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51538       };
51539     } catch (std::exception& e) {
51540       {
51541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51542       };
51543     } catch (Dali::DaliException e) {
51544       {
51545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51546       };
51547     } catch (...) {
51548       {
51549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51550       };
51551     }
51552   }
51553
51554 }
51555
51556
51557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51558   void * jresult ;
51559   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51560   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51561   Dali::Vector< int >::Iterator result;
51562
51563   arg1 = (Dali::Vector< int > *)jarg1;
51564   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51565   {
51566     try {
51567       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51568     } catch (std::out_of_range& e) {
51569       {
51570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51571       };
51572     } catch (std::exception& e) {
51573       {
51574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51575       };
51576     } catch (Dali::DaliException e) {
51577       {
51578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51579       };
51580     } catch (...) {
51581       {
51582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51583       };
51584     }
51585   }
51586
51587   jresult = (void *)result;
51588   return jresult;
51589 }
51590
51591
51592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51593   void * jresult ;
51594   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51595   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51596   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51597   Dali::Vector< int >::Iterator result;
51598
51599   arg1 = (Dali::Vector< int > *)jarg1;
51600   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51601   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51602   {
51603     try {
51604       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51605     } catch (std::out_of_range& e) {
51606       {
51607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51608       };
51609     } catch (std::exception& e) {
51610       {
51611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51612       };
51613     } catch (Dali::DaliException e) {
51614       {
51615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51616       };
51617     } catch (...) {
51618       {
51619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51620       };
51621     }
51622   }
51623
51624   jresult = (void *)result;
51625   return jresult;
51626 }
51627
51628
51629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51630   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51631   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51632
51633   arg1 = (Dali::Vector< int > *)jarg1;
51634   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51635   {
51636     try {
51637       (arg1)->Remove(arg2);
51638     } catch (std::out_of_range& e) {
51639       {
51640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51641       };
51642     } catch (std::exception& e) {
51643       {
51644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51645       };
51646     } catch (Dali::DaliException e) {
51647       {
51648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51649       };
51650     } catch (...) {
51651       {
51652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51653       };
51654     }
51655   }
51656
51657 }
51658
51659
51660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51661   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51662   Dali::Vector< int > *arg2 = 0 ;
51663
51664   arg1 = (Dali::Vector< int > *)jarg1;
51665   arg2 = (Dali::Vector< int > *)jarg2;
51666   if (!arg2) {
51667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51668     return ;
51669   }
51670   {
51671     try {
51672       (arg1)->Swap(*arg2);
51673     } catch (std::out_of_range& e) {
51674       {
51675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51676       };
51677     } catch (std::exception& e) {
51678       {
51679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51680       };
51681     } catch (Dali::DaliException e) {
51682       {
51683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51684       };
51685     } catch (...) {
51686       {
51687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51688       };
51689     }
51690   }
51691
51692 }
51693
51694
51695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51696   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51697
51698   arg1 = (Dali::Vector< int > *)jarg1;
51699   {
51700     try {
51701       (arg1)->Clear();
51702     } catch (std::out_of_range& e) {
51703       {
51704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51705       };
51706     } catch (std::exception& e) {
51707       {
51708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51709       };
51710     } catch (Dali::DaliException e) {
51711       {
51712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51713       };
51714     } catch (...) {
51715       {
51716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51717       };
51718     }
51719   }
51720
51721 }
51722
51723
51724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51725   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51726
51727   arg1 = (Dali::Vector< int > *)jarg1;
51728   {
51729     try {
51730       (arg1)->Release();
51731     } catch (std::out_of_range& e) {
51732       {
51733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51734       };
51735     } catch (std::exception& e) {
51736       {
51737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51738       };
51739     } catch (Dali::DaliException e) {
51740       {
51741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51742       };
51743     } catch (...) {
51744       {
51745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51746       };
51747     }
51748   }
51749
51750 }
51751
51752
51753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51754   int jresult ;
51755   int result;
51756
51757   result = (int)Dali::Vector< float >::BaseType;
51758   jresult = (int)result;
51759   return jresult;
51760 }
51761
51762
51763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51764   void * jresult ;
51765   Dali::Vector< float > *result = 0 ;
51766
51767   {
51768     try {
51769       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51770     } catch (std::out_of_range& e) {
51771       {
51772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51773       };
51774     } catch (std::exception& e) {
51775       {
51776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51777       };
51778     } catch (Dali::DaliException e) {
51779       {
51780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51781       };
51782     } catch (...) {
51783       {
51784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51785       };
51786     }
51787   }
51788
51789   jresult = (void *)result;
51790   return jresult;
51791 }
51792
51793
51794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51795   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51796
51797   arg1 = (Dali::Vector< float > *)jarg1;
51798   {
51799     try {
51800       delete arg1;
51801     } catch (std::out_of_range& e) {
51802       {
51803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51804       };
51805     } catch (std::exception& e) {
51806       {
51807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51808       };
51809     } catch (Dali::DaliException e) {
51810       {
51811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51812       };
51813     } catch (...) {
51814       {
51815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51816       };
51817     }
51818   }
51819
51820 }
51821
51822
51823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51824   void * jresult ;
51825   Dali::Vector< float > *arg1 = 0 ;
51826   Dali::Vector< float > *result = 0 ;
51827
51828   arg1 = (Dali::Vector< float > *)jarg1;
51829   if (!arg1) {
51830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51831     return 0;
51832   }
51833   {
51834     try {
51835       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51836     } catch (std::out_of_range& e) {
51837       {
51838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51839       };
51840     } catch (std::exception& e) {
51841       {
51842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51843       };
51844     } catch (Dali::DaliException e) {
51845       {
51846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51847       };
51848     } catch (...) {
51849       {
51850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51851       };
51852     }
51853   }
51854
51855   jresult = (void *)result;
51856   return jresult;
51857 }
51858
51859
51860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51861   void * jresult ;
51862   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51863   Dali::Vector< float > *arg2 = 0 ;
51864   Dali::Vector< float > *result = 0 ;
51865
51866   arg1 = (Dali::Vector< float > *)jarg1;
51867   arg2 = (Dali::Vector< float > *)jarg2;
51868   if (!arg2) {
51869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51870     return 0;
51871   }
51872   {
51873     try {
51874       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51875     } catch (std::out_of_range& e) {
51876       {
51877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51878       };
51879     } catch (std::exception& e) {
51880       {
51881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51882       };
51883     } catch (Dali::DaliException e) {
51884       {
51885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51886       };
51887     } catch (...) {
51888       {
51889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51890       };
51891     }
51892   }
51893
51894   jresult = (void *)result;
51895   return jresult;
51896 }
51897
51898
51899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51900   void * jresult ;
51901   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51902   Dali::Vector< float >::Iterator result;
51903
51904   arg1 = (Dali::Vector< float > *)jarg1;
51905   {
51906     try {
51907       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51908     } catch (std::out_of_range& e) {
51909       {
51910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51911       };
51912     } catch (std::exception& e) {
51913       {
51914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51915       };
51916     } catch (Dali::DaliException e) {
51917       {
51918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51919       };
51920     } catch (...) {
51921       {
51922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51923       };
51924     }
51925   }
51926
51927   jresult = (void *)result;
51928   return jresult;
51929 }
51930
51931
51932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51933   void * jresult ;
51934   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51935   Dali::Vector< float >::Iterator result;
51936
51937   arg1 = (Dali::Vector< float > *)jarg1;
51938   {
51939     try {
51940       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51941     } catch (std::out_of_range& e) {
51942       {
51943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51944       };
51945     } catch (std::exception& e) {
51946       {
51947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51948       };
51949     } catch (Dali::DaliException e) {
51950       {
51951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51952       };
51953     } catch (...) {
51954       {
51955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51956       };
51957     }
51958   }
51959
51960   jresult = (void *)result;
51961   return jresult;
51962 }
51963
51964
51965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51966   void * jresult ;
51967   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51968   Dali::Vector< float >::SizeType arg2 ;
51969   Dali::Vector< float >::ItemType *result = 0 ;
51970
51971   arg1 = (Dali::Vector< float > *)jarg1;
51972   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51973   {
51974     try {
51975       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51976     } catch (std::out_of_range& e) {
51977       {
51978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51979       };
51980     } catch (std::exception& e) {
51981       {
51982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51983       };
51984     } catch (Dali::DaliException e) {
51985       {
51986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51987       };
51988     } catch (...) {
51989       {
51990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51991       };
51992     }
51993   }
51994
51995   jresult = (void *)result;
51996   return jresult;
51997 }
51998
51999
52000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
52001   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52002   Dali::Vector< float >::ItemType *arg2 = 0 ;
52003   Dali::Vector< float >::ItemType temp2 ;
52004
52005   arg1 = (Dali::Vector< float > *)jarg1;
52006   temp2 = (Dali::Vector< float >::ItemType)jarg2;
52007   arg2 = &temp2;
52008   {
52009     try {
52010       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
52011     } catch (std::out_of_range& e) {
52012       {
52013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52014       };
52015     } catch (std::exception& e) {
52016       {
52017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52018       };
52019     } catch (Dali::DaliException e) {
52020       {
52021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52022       };
52023     } catch (...) {
52024       {
52025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52026       };
52027     }
52028   }
52029
52030 }
52031
52032
52033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
52034   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52035   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52036   Dali::Vector< float >::ItemType *arg3 = 0 ;
52037   Dali::Vector< float >::ItemType temp3 ;
52038
52039   arg1 = (Dali::Vector< float > *)jarg1;
52040   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52041   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52042   arg3 = &temp3;
52043   {
52044     try {
52045       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52046     } catch (std::out_of_range& e) {
52047       {
52048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52049       };
52050     } catch (std::exception& e) {
52051       {
52052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52053       };
52054     } catch (Dali::DaliException e) {
52055       {
52056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52057       };
52058     } catch (...) {
52059       {
52060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52061       };
52062     }
52063   }
52064
52065 }
52066
52067
52068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52069   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52070   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52071   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52072   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
52073
52074   arg1 = (Dali::Vector< float > *)jarg1;
52075   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52076   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52077   arg4 = (Dali::Vector< float >::Iterator)jarg4;
52078   {
52079     try {
52080       (arg1)->Insert(arg2,arg3,arg4);
52081     } catch (std::out_of_range& e) {
52082       {
52083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52084       };
52085     } catch (std::exception& e) {
52086       {
52087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52088       };
52089     } catch (Dali::DaliException e) {
52090       {
52091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52092       };
52093     } catch (...) {
52094       {
52095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52096       };
52097     }
52098   }
52099
52100 }
52101
52102
52103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52104   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52105   Dali::Vector< float >::SizeType arg2 ;
52106
52107   arg1 = (Dali::Vector< float > *)jarg1;
52108   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52109   {
52110     try {
52111       (arg1)->Reserve(arg2);
52112     } catch (std::out_of_range& e) {
52113       {
52114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52115       };
52116     } catch (std::exception& e) {
52117       {
52118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52119       };
52120     } catch (Dali::DaliException e) {
52121       {
52122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52123       };
52124     } catch (...) {
52125       {
52126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52127       };
52128     }
52129   }
52130
52131 }
52132
52133 //// ========================= end of part 2 =============================
52134
52135 //// ========================== start part 3 ===============================
52136
52137
52138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52139   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52140   Dali::Vector< float >::SizeType arg2 ;
52141
52142   arg1 = (Dali::Vector< float > *)jarg1;
52143   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52144   {
52145     try {
52146       (arg1)->Resize(arg2);
52147     } catch (std::out_of_range& e) {
52148       {
52149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52150       };
52151     } catch (std::exception& e) {
52152       {
52153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52154       };
52155     } catch (Dali::DaliException e) {
52156       {
52157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52158       };
52159     } catch (...) {
52160       {
52161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52162       };
52163     }
52164   }
52165
52166 }
52167
52168
52169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52170   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52171   Dali::Vector< float >::SizeType arg2 ;
52172   Dali::Vector< float >::ItemType *arg3 = 0 ;
52173   Dali::Vector< float >::ItemType temp3 ;
52174
52175   arg1 = (Dali::Vector< float > *)jarg1;
52176   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52177   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52178   arg3 = &temp3;
52179   {
52180     try {
52181       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52182     } catch (std::out_of_range& e) {
52183       {
52184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52185       };
52186     } catch (std::exception& e) {
52187       {
52188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52189       };
52190     } catch (Dali::DaliException e) {
52191       {
52192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52193       };
52194     } catch (...) {
52195       {
52196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52197       };
52198     }
52199   }
52200
52201 }
52202
52203
52204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52205   void * jresult ;
52206   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52207   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52208   Dali::Vector< float >::Iterator result;
52209
52210   arg1 = (Dali::Vector< float > *)jarg1;
52211   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52212   {
52213     try {
52214       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52215     } catch (std::out_of_range& e) {
52216       {
52217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52218       };
52219     } catch (std::exception& e) {
52220       {
52221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52222       };
52223     } catch (Dali::DaliException e) {
52224       {
52225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52226       };
52227     } catch (...) {
52228       {
52229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52230       };
52231     }
52232   }
52233
52234   jresult = (void *)result;
52235   return jresult;
52236 }
52237
52238
52239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52240   void * jresult ;
52241   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52242   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52243   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52244   Dali::Vector< float >::Iterator result;
52245
52246   arg1 = (Dali::Vector< float > *)jarg1;
52247   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52248   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52249   {
52250     try {
52251       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52252     } catch (std::out_of_range& e) {
52253       {
52254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52255       };
52256     } catch (std::exception& e) {
52257       {
52258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52259       };
52260     } catch (Dali::DaliException e) {
52261       {
52262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52263       };
52264     } catch (...) {
52265       {
52266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52267       };
52268     }
52269   }
52270
52271   jresult = (void *)result;
52272   return jresult;
52273 }
52274
52275
52276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52277   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52278   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52279
52280   arg1 = (Dali::Vector< float > *)jarg1;
52281   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52282   {
52283     try {
52284       (arg1)->Remove(arg2);
52285     } catch (std::out_of_range& e) {
52286       {
52287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52288       };
52289     } catch (std::exception& e) {
52290       {
52291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52292       };
52293     } catch (Dali::DaliException e) {
52294       {
52295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52296       };
52297     } catch (...) {
52298       {
52299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52300       };
52301     }
52302   }
52303
52304 }
52305
52306
52307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52308   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52309   Dali::Vector< float > *arg2 = 0 ;
52310
52311   arg1 = (Dali::Vector< float > *)jarg1;
52312   arg2 = (Dali::Vector< float > *)jarg2;
52313   if (!arg2) {
52314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52315     return ;
52316   }
52317   {
52318     try {
52319       (arg1)->Swap(*arg2);
52320     } catch (std::out_of_range& e) {
52321       {
52322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52323       };
52324     } catch (std::exception& e) {
52325       {
52326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52327       };
52328     } catch (Dali::DaliException e) {
52329       {
52330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52331       };
52332     } catch (...) {
52333       {
52334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52335       };
52336     }
52337   }
52338
52339 }
52340
52341
52342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52343   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52344
52345   arg1 = (Dali::Vector< float > *)jarg1;
52346   {
52347     try {
52348       (arg1)->Clear();
52349     } catch (std::out_of_range& e) {
52350       {
52351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52352       };
52353     } catch (std::exception& e) {
52354       {
52355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52356       };
52357     } catch (Dali::DaliException e) {
52358       {
52359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52360       };
52361     } catch (...) {
52362       {
52363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52364       };
52365     }
52366   }
52367
52368 }
52369
52370
52371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52372   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52373
52374   arg1 = (Dali::Vector< float > *)jarg1;
52375   {
52376     try {
52377       (arg1)->Release();
52378     } catch (std::out_of_range& e) {
52379       {
52380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52381       };
52382     } catch (std::exception& e) {
52383       {
52384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52385       };
52386     } catch (Dali::DaliException e) {
52387       {
52388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52389       };
52390     } catch (...) {
52391       {
52392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52393       };
52394     }
52395   }
52396
52397 }
52398
52399
52400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52401   int jresult ;
52402   int result;
52403
52404   result = (int)Dali::Vector< unsigned char >::BaseType;
52405   jresult = (int)result;
52406   return jresult;
52407 }
52408
52409
52410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52411   void * jresult ;
52412   Dali::Vector< unsigned char > *result = 0 ;
52413
52414   {
52415     try {
52416       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52417     } catch (std::out_of_range& e) {
52418       {
52419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52420       };
52421     } catch (std::exception& e) {
52422       {
52423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52424       };
52425     } catch (Dali::DaliException e) {
52426       {
52427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52428       };
52429     } catch (...) {
52430       {
52431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52432       };
52433     }
52434   }
52435
52436   jresult = (void *)result;
52437   return jresult;
52438 }
52439
52440
52441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52442   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52443
52444   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52445   {
52446     try {
52447       delete arg1;
52448     } catch (std::out_of_range& e) {
52449       {
52450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52451       };
52452     } catch (std::exception& e) {
52453       {
52454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52455       };
52456     } catch (Dali::DaliException e) {
52457       {
52458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52459       };
52460     } catch (...) {
52461       {
52462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52463       };
52464     }
52465   }
52466
52467 }
52468
52469
52470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52471   void * jresult ;
52472   Dali::Vector< unsigned char > *arg1 = 0 ;
52473   Dali::Vector< unsigned char > *result = 0 ;
52474
52475   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52476   if (!arg1) {
52477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52478     return 0;
52479   }
52480   {
52481     try {
52482       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52483     } catch (std::out_of_range& e) {
52484       {
52485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52486       };
52487     } catch (std::exception& e) {
52488       {
52489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52490       };
52491     } catch (Dali::DaliException e) {
52492       {
52493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52494       };
52495     } catch (...) {
52496       {
52497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52498       };
52499     }
52500   }
52501
52502   jresult = (void *)result;
52503   return jresult;
52504 }
52505
52506
52507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52508   void * jresult ;
52509   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52510   Dali::Vector< unsigned char > *arg2 = 0 ;
52511   Dali::Vector< unsigned char > *result = 0 ;
52512
52513   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52514   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52515   if (!arg2) {
52516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52517     return 0;
52518   }
52519   {
52520     try {
52521       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52522     } catch (std::out_of_range& e) {
52523       {
52524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52525       };
52526     } catch (std::exception& e) {
52527       {
52528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52529       };
52530     } catch (Dali::DaliException e) {
52531       {
52532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52533       };
52534     } catch (...) {
52535       {
52536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52537       };
52538     }
52539   }
52540
52541   jresult = (void *)result;
52542   return jresult;
52543 }
52544
52545
52546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52547   void * jresult ;
52548   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52549   Dali::Vector< unsigned char >::Iterator result;
52550
52551   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52552   {
52553     try {
52554       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52555     } catch (std::out_of_range& e) {
52556       {
52557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52558       };
52559     } catch (std::exception& e) {
52560       {
52561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52562       };
52563     } catch (Dali::DaliException e) {
52564       {
52565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52566       };
52567     } catch (...) {
52568       {
52569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52570       };
52571     }
52572   }
52573
52574   jresult = (void *)result;
52575   return jresult;
52576 }
52577
52578
52579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52580   void * jresult ;
52581   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52582   Dali::Vector< unsigned char >::Iterator result;
52583
52584   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52585   {
52586     try {
52587       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52588     } catch (std::out_of_range& e) {
52589       {
52590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52591       };
52592     } catch (std::exception& e) {
52593       {
52594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52595       };
52596     } catch (Dali::DaliException e) {
52597       {
52598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52599       };
52600     } catch (...) {
52601       {
52602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52603       };
52604     }
52605   }
52606
52607   jresult = (void *)result;
52608   return jresult;
52609 }
52610
52611
52612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52613   void * jresult ;
52614   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52615   Dali::Vector< unsigned char >::SizeType arg2 ;
52616   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52617
52618   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52619   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52620   {
52621     try {
52622       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52623     } catch (std::out_of_range& e) {
52624       {
52625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52626       };
52627     } catch (std::exception& e) {
52628       {
52629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52630       };
52631     } catch (Dali::DaliException e) {
52632       {
52633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52634       };
52635     } catch (...) {
52636       {
52637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52638       };
52639     }
52640   }
52641
52642   jresult = (void *)result;
52643   return jresult;
52644 }
52645
52646
52647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52648   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52649   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52650   Dali::Vector< unsigned char >::ItemType temp2 ;
52651
52652   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52653   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52654   arg2 = &temp2;
52655   {
52656     try {
52657       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52658     } catch (std::out_of_range& e) {
52659       {
52660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52661       };
52662     } catch (std::exception& e) {
52663       {
52664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52665       };
52666     } catch (Dali::DaliException e) {
52667       {
52668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52669       };
52670     } catch (...) {
52671       {
52672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52673       };
52674     }
52675   }
52676
52677 }
52678
52679
52680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52681   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52682   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52683   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52684   Dali::Vector< unsigned char >::ItemType temp3 ;
52685
52686   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52687   arg2 = jarg2;
52688   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52689   arg3 = &temp3;
52690   {
52691     try {
52692       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52693     } catch (std::out_of_range& e) {
52694       {
52695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52696       };
52697     } catch (std::exception& e) {
52698       {
52699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52700       };
52701     } catch (Dali::DaliException e) {
52702       {
52703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52704       };
52705     } catch (...) {
52706       {
52707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52708       };
52709     }
52710   }
52711
52712
52713
52714 }
52715
52716
52717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52718   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52719   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52720   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52721   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52722
52723   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52724   arg2 = jarg2;
52725   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52726   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52727   {
52728     try {
52729       (arg1)->Insert(arg2,arg3,arg4);
52730     } catch (std::out_of_range& e) {
52731       {
52732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52733       };
52734     } catch (std::exception& e) {
52735       {
52736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52737       };
52738     } catch (Dali::DaliException e) {
52739       {
52740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52741       };
52742     } catch (...) {
52743       {
52744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52745       };
52746     }
52747   }
52748
52749
52750
52751 }
52752
52753
52754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52755   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52756   Dali::Vector< unsigned char >::SizeType arg2 ;
52757
52758   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52759   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52760   {
52761     try {
52762       (arg1)->Reserve(arg2);
52763     } catch (std::out_of_range& e) {
52764       {
52765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52766       };
52767     } catch (std::exception& e) {
52768       {
52769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52770       };
52771     } catch (Dali::DaliException e) {
52772       {
52773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52774       };
52775     } catch (...) {
52776       {
52777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52778       };
52779     }
52780   }
52781
52782 }
52783
52784
52785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52786   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52787   Dali::Vector< unsigned char >::SizeType arg2 ;
52788
52789   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52790   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52791   {
52792     try {
52793       (arg1)->Resize(arg2);
52794     } catch (std::out_of_range& e) {
52795       {
52796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52797       };
52798     } catch (std::exception& e) {
52799       {
52800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52801       };
52802     } catch (Dali::DaliException e) {
52803       {
52804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52805       };
52806     } catch (...) {
52807       {
52808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52809       };
52810     }
52811   }
52812
52813 }
52814
52815
52816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52817   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52818   Dali::Vector< unsigned char >::SizeType arg2 ;
52819   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52820   Dali::Vector< unsigned char >::ItemType temp3 ;
52821
52822   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52823   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52824   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52825   arg3 = &temp3;
52826   {
52827     try {
52828       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52829     } catch (std::out_of_range& e) {
52830       {
52831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52832       };
52833     } catch (std::exception& e) {
52834       {
52835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52836       };
52837     } catch (Dali::DaliException e) {
52838       {
52839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52840       };
52841     } catch (...) {
52842       {
52843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52844       };
52845     }
52846   }
52847
52848 }
52849
52850
52851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52852   void * jresult ;
52853   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52854   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52855   Dali::Vector< unsigned char >::Iterator result;
52856
52857   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52858   arg2 = jarg2;
52859   {
52860     try {
52861       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52862     } catch (std::out_of_range& e) {
52863       {
52864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52865       };
52866     } catch (std::exception& e) {
52867       {
52868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52869       };
52870     } catch (Dali::DaliException e) {
52871       {
52872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52873       };
52874     } catch (...) {
52875       {
52876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52877       };
52878     }
52879   }
52880
52881   jresult = (void *)result;
52882
52883
52884   return jresult;
52885 }
52886
52887
52888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52889   void * jresult ;
52890   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52891   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52892   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52893   Dali::Vector< unsigned char >::Iterator result;
52894
52895   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52896   arg2 = jarg2;
52897   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52898   {
52899     try {
52900       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52901     } catch (std::out_of_range& e) {
52902       {
52903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52904       };
52905     } catch (std::exception& e) {
52906       {
52907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52908       };
52909     } catch (Dali::DaliException e) {
52910       {
52911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52912       };
52913     } catch (...) {
52914       {
52915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52916       };
52917     }
52918   }
52919
52920   jresult = (void *)result;
52921
52922
52923   return jresult;
52924 }
52925
52926
52927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52928   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52929   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52930
52931   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52932   arg2 = jarg2;
52933   {
52934     try {
52935       (arg1)->Remove(arg2);
52936     } catch (std::out_of_range& e) {
52937       {
52938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52939       };
52940     } catch (std::exception& e) {
52941       {
52942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52943       };
52944     } catch (Dali::DaliException e) {
52945       {
52946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52947       };
52948     } catch (...) {
52949       {
52950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52951       };
52952     }
52953   }
52954
52955
52956
52957 }
52958
52959
52960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52961   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52962   Dali::Vector< unsigned char > *arg2 = 0 ;
52963
52964   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52965   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52966   if (!arg2) {
52967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52968     return ;
52969   }
52970   {
52971     try {
52972       (arg1)->Swap(*arg2);
52973     } catch (std::out_of_range& e) {
52974       {
52975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52976       };
52977     } catch (std::exception& e) {
52978       {
52979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52980       };
52981     } catch (Dali::DaliException e) {
52982       {
52983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52984       };
52985     } catch (...) {
52986       {
52987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52988       };
52989     }
52990   }
52991
52992 }
52993
52994
52995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52996   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52997
52998   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52999   {
53000     try {
53001       (arg1)->Clear();
53002     } catch (std::out_of_range& e) {
53003       {
53004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53005       };
53006     } catch (std::exception& e) {
53007       {
53008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53009       };
53010     } catch (Dali::DaliException e) {
53011       {
53012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53013       };
53014     } catch (...) {
53015       {
53016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53017       };
53018     }
53019   }
53020
53021 }
53022
53023
53024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
53025   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53026
53027   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53028   {
53029     try {
53030       (arg1)->Release();
53031     } catch (std::out_of_range& e) {
53032       {
53033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53034       };
53035     } catch (std::exception& e) {
53036       {
53037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53038       };
53039     } catch (Dali::DaliException e) {
53040       {
53041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53042       };
53043     } catch (...) {
53044       {
53045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53046       };
53047     }
53048   }
53049
53050 }
53051
53052
53053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
53054   int jresult ;
53055   int result;
53056
53057   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
53058   jresult = (int)result;
53059   return jresult;
53060 }
53061
53062
53063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
53064   void * jresult ;
53065   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53066
53067   {
53068     try {
53069       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
53070     } catch (std::out_of_range& e) {
53071       {
53072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53073       };
53074     } catch (std::exception& e) {
53075       {
53076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53077       };
53078     } catch (Dali::DaliException e) {
53079       {
53080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53081       };
53082     } catch (...) {
53083       {
53084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53085       };
53086     }
53087   }
53088
53089   jresult = (void *)result;
53090   return jresult;
53091 }
53092
53093
53094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53095   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53096
53097   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53098   {
53099     try {
53100       delete arg1;
53101     } catch (std::out_of_range& e) {
53102       {
53103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53104       };
53105     } catch (std::exception& e) {
53106       {
53107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53108       };
53109     } catch (Dali::DaliException e) {
53110       {
53111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53112       };
53113     } catch (...) {
53114       {
53115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53116       };
53117     }
53118   }
53119
53120 }
53121
53122
53123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53124   void * jresult ;
53125   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53126   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53127
53128   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53129   if (!arg1) {
53130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53131     return 0;
53132   }
53133   {
53134     try {
53135       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53136     } catch (std::out_of_range& e) {
53137       {
53138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53139       };
53140     } catch (std::exception& e) {
53141       {
53142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53143       };
53144     } catch (Dali::DaliException e) {
53145       {
53146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53147       };
53148     } catch (...) {
53149       {
53150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53151       };
53152     }
53153   }
53154
53155   jresult = (void *)result;
53156   return jresult;
53157 }
53158
53159
53160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53161   void * jresult ;
53162   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53163   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53164   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53165
53166   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53167   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53168   if (!arg2) {
53169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53170     return 0;
53171   }
53172   {
53173     try {
53174       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53175     } catch (std::out_of_range& e) {
53176       {
53177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53178       };
53179     } catch (std::exception& e) {
53180       {
53181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53182       };
53183     } catch (Dali::DaliException e) {
53184       {
53185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53186       };
53187     } catch (...) {
53188       {
53189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53190       };
53191     }
53192   }
53193
53194   jresult = (void *)result;
53195   return jresult;
53196 }
53197
53198
53199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53200   void * jresult ;
53201   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53202   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53203
53204   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53205   {
53206     try {
53207       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53208     } catch (std::out_of_range& e) {
53209       {
53210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53211       };
53212     } catch (std::exception& e) {
53213       {
53214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53215       };
53216     } catch (Dali::DaliException e) {
53217       {
53218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53219       };
53220     } catch (...) {
53221       {
53222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53223       };
53224     }
53225   }
53226
53227   jresult = (void *)result;
53228   return jresult;
53229 }
53230
53231
53232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53233   void * jresult ;
53234   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53235   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53236
53237   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53238   {
53239     try {
53240       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53241     } catch (std::out_of_range& e) {
53242       {
53243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53244       };
53245     } catch (std::exception& e) {
53246       {
53247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53248       };
53249     } catch (Dali::DaliException e) {
53250       {
53251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53252       };
53253     } catch (...) {
53254       {
53255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53256       };
53257     }
53258   }
53259
53260   jresult = (void *)result;
53261   return jresult;
53262 }
53263
53264
53265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53266   void * jresult ;
53267   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53268   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53269   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53270
53271   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53272   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53273   {
53274     try {
53275       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53276     } catch (std::out_of_range& e) {
53277       {
53278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53279       };
53280     } catch (std::exception& e) {
53281       {
53282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53283       };
53284     } catch (Dali::DaliException e) {
53285       {
53286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53287       };
53288     } catch (...) {
53289       {
53290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53291       };
53292     }
53293   }
53294
53295   jresult = (void *)result;
53296   return jresult;
53297 }
53298
53299
53300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53301   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53302   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53303
53304   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53305   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53306   if (!arg2) {
53307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53308     return ;
53309   }
53310   {
53311     try {
53312       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53313     } catch (std::out_of_range& e) {
53314       {
53315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53316       };
53317     } catch (std::exception& e) {
53318       {
53319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53320       };
53321     } catch (Dali::DaliException e) {
53322       {
53323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53324       };
53325     } catch (...) {
53326       {
53327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53328       };
53329     }
53330   }
53331
53332 }
53333
53334
53335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53336   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53337   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53338   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53339
53340   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53341   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53342   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53343   if (!arg3) {
53344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53345     return ;
53346   }
53347   {
53348     try {
53349       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53350     } catch (std::out_of_range& e) {
53351       {
53352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53353       };
53354     } catch (std::exception& e) {
53355       {
53356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53357       };
53358     } catch (Dali::DaliException e) {
53359       {
53360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53361       };
53362     } catch (...) {
53363       {
53364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53365       };
53366     }
53367   }
53368
53369 }
53370
53371
53372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53373   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53374   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53375   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53376   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53377
53378   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53379   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53380   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53381   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53382   {
53383     try {
53384       (arg1)->Insert(arg2,arg3,arg4);
53385     } catch (std::out_of_range& e) {
53386       {
53387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53388       };
53389     } catch (std::exception& e) {
53390       {
53391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53392       };
53393     } catch (Dali::DaliException e) {
53394       {
53395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53396       };
53397     } catch (...) {
53398       {
53399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53400       };
53401     }
53402   }
53403
53404 }
53405
53406
53407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53408   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53409   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53410
53411   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53412   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53413   {
53414     try {
53415       (arg1)->Reserve(arg2);
53416     } catch (std::out_of_range& e) {
53417       {
53418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53419       };
53420     } catch (std::exception& e) {
53421       {
53422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53423       };
53424     } catch (Dali::DaliException e) {
53425       {
53426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53427       };
53428     } catch (...) {
53429       {
53430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53431       };
53432     }
53433   }
53434
53435 }
53436
53437
53438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53439   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53440   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53441
53442   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53443   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53444   {
53445     try {
53446       (arg1)->Resize(arg2);
53447     } catch (std::out_of_range& e) {
53448       {
53449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53450       };
53451     } catch (std::exception& e) {
53452       {
53453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53454       };
53455     } catch (Dali::DaliException e) {
53456       {
53457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53458       };
53459     } catch (...) {
53460       {
53461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53462       };
53463     }
53464   }
53465
53466 }
53467
53468
53469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53470   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53471   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53472   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53473
53474   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53475   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53476   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53477   if (!arg3) {
53478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53479     return ;
53480   }
53481   {
53482     try {
53483       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53484     } catch (std::out_of_range& e) {
53485       {
53486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53487       };
53488     } catch (std::exception& e) {
53489       {
53490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53491       };
53492     } catch (Dali::DaliException e) {
53493       {
53494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53495       };
53496     } catch (...) {
53497       {
53498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53499       };
53500     }
53501   }
53502
53503 }
53504
53505
53506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53507   void * jresult ;
53508   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53509   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53510   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53511
53512   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53513   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53514   {
53515     try {
53516       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53517     } catch (std::out_of_range& e) {
53518       {
53519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53520       };
53521     } catch (std::exception& e) {
53522       {
53523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53524       };
53525     } catch (Dali::DaliException e) {
53526       {
53527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53528       };
53529     } catch (...) {
53530       {
53531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53532       };
53533     }
53534   }
53535
53536   jresult = (void *)result;
53537   return jresult;
53538 }
53539
53540
53541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53542   void * jresult ;
53543   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53544   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53545   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53546   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53547
53548   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53549   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53550   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53551   {
53552     try {
53553       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53554     } catch (std::out_of_range& e) {
53555       {
53556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53557       };
53558     } catch (std::exception& e) {
53559       {
53560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53561       };
53562     } catch (Dali::DaliException e) {
53563       {
53564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53565       };
53566     } catch (...) {
53567       {
53568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53569       };
53570     }
53571   }
53572
53573   jresult = (void *)result;
53574   return jresult;
53575 }
53576
53577
53578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53579   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53580   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53581
53582   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53583   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53584   {
53585     try {
53586       (arg1)->Remove(arg2);
53587     } catch (std::out_of_range& e) {
53588       {
53589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53590       };
53591     } catch (std::exception& e) {
53592       {
53593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53594       };
53595     } catch (Dali::DaliException e) {
53596       {
53597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53598       };
53599     } catch (...) {
53600       {
53601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53602       };
53603     }
53604   }
53605
53606 }
53607
53608
53609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53610   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53611   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53612
53613   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53614   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53615   if (!arg2) {
53616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53617     return ;
53618   }
53619   {
53620     try {
53621       (arg1)->Swap(*arg2);
53622     } catch (std::out_of_range& e) {
53623       {
53624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53625       };
53626     } catch (std::exception& e) {
53627       {
53628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53629       };
53630     } catch (Dali::DaliException e) {
53631       {
53632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53633       };
53634     } catch (...) {
53635       {
53636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53637       };
53638     }
53639   }
53640
53641 }
53642
53643
53644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53645   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53646
53647   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53648   {
53649     try {
53650       (arg1)->Clear();
53651     } catch (std::out_of_range& e) {
53652       {
53653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53654       };
53655     } catch (std::exception& e) {
53656       {
53657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53658       };
53659     } catch (Dali::DaliException e) {
53660       {
53661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53662       };
53663     } catch (...) {
53664       {
53665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53666       };
53667     }
53668   }
53669
53670 }
53671
53672
53673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53674   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53675
53676   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53677   {
53678     try {
53679       (arg1)->Release();
53680     } catch (std::out_of_range& e) {
53681       {
53682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53683       };
53684     } catch (std::exception& e) {
53685       {
53686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53687       };
53688     } catch (Dali::DaliException e) {
53689       {
53690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53691       };
53692     } catch (...) {
53693       {
53694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53695       };
53696     }
53697   }
53698
53699 }
53700
53701
53702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53703   void * jresult ;
53704   Dali::Signal< void () > *result = 0 ;
53705
53706   {
53707     try {
53708       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53709     } catch (std::out_of_range& e) {
53710       {
53711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53712       };
53713     } catch (std::exception& e) {
53714       {
53715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53716       };
53717     } catch (Dali::DaliException e) {
53718       {
53719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53720       };
53721     } catch (...) {
53722       {
53723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53724       };
53725     }
53726   }
53727
53728   jresult = (void *)result;
53729   return jresult;
53730 }
53731
53732
53733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53734   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53735
53736   arg1 = (Dali::Signal< void () > *)jarg1;
53737   {
53738     try {
53739       delete arg1;
53740     } catch (std::out_of_range& e) {
53741       {
53742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53743       };
53744     } catch (std::exception& e) {
53745       {
53746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53747       };
53748     } catch (Dali::DaliException e) {
53749       {
53750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53751       };
53752     } catch (...) {
53753       {
53754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53755       };
53756     }
53757   }
53758
53759 }
53760
53761
53762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53763   unsigned int jresult ;
53764   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53765   bool result;
53766
53767   arg1 = (Dali::Signal< void () > *)jarg1;
53768   {
53769     try {
53770       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53771     } catch (std::out_of_range& e) {
53772       {
53773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53774       };
53775     } catch (std::exception& e) {
53776       {
53777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53778       };
53779     } catch (Dali::DaliException e) {
53780       {
53781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53782       };
53783     } catch (...) {
53784       {
53785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53786       };
53787     }
53788   }
53789
53790   jresult = result;
53791   return jresult;
53792 }
53793
53794
53795 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53796   unsigned long jresult ;
53797   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53798   std::size_t result;
53799
53800   arg1 = (Dali::Signal< void () > *)jarg1;
53801   {
53802     try {
53803       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53804     } catch (std::out_of_range& e) {
53805       {
53806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53807       };
53808     } catch (std::exception& e) {
53809       {
53810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53811       };
53812     } catch (Dali::DaliException e) {
53813       {
53814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53815       };
53816     } catch (...) {
53817       {
53818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53819       };
53820     }
53821   }
53822
53823   jresult = (unsigned long)result;
53824   return jresult;
53825 }
53826
53827
53828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53829   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53830   void (*arg2)() = (void (*)()) 0 ;
53831
53832   arg1 = (Dali::Signal< void () > *)jarg1;
53833   arg2 = (void (*)())jarg2;
53834   {
53835     try {
53836       (arg1)->Connect(arg2);
53837     } catch (std::out_of_range& e) {
53838       {
53839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53840       };
53841     } catch (std::exception& e) {
53842       {
53843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53844       };
53845     } catch (Dali::DaliException e) {
53846       {
53847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53848       };
53849     } catch (...) {
53850       {
53851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53852       };
53853     }
53854   }
53855
53856 }
53857
53858
53859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53860   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53861   void (*arg2)() = (void (*)()) 0 ;
53862
53863   arg1 = (Dali::Signal< void () > *)jarg1;
53864   arg2 = (void (*)())jarg2;
53865   {
53866     try {
53867       (arg1)->Disconnect(arg2);
53868     } catch (std::out_of_range& e) {
53869       {
53870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53871       };
53872     } catch (std::exception& e) {
53873       {
53874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53875       };
53876     } catch (Dali::DaliException e) {
53877       {
53878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53879       };
53880     } catch (...) {
53881       {
53882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53883       };
53884     }
53885   }
53886
53887 }
53888
53889
53890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53891   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53892   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53893   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53894
53895   arg1 = (Dali::Signal< void () > *)jarg1;
53896   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53897   arg3 = (Dali::FunctorDelegate *)jarg3;
53898   {
53899     try {
53900       (arg1)->Connect(arg2,arg3);
53901     } catch (std::out_of_range& e) {
53902       {
53903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53904       };
53905     } catch (std::exception& e) {
53906       {
53907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53908       };
53909     } catch (Dali::DaliException e) {
53910       {
53911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53912       };
53913     } catch (...) {
53914       {
53915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53916       };
53917     }
53918   }
53919
53920 }
53921
53922
53923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53924   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53925
53926   arg1 = (Dali::Signal< void () > *)jarg1;
53927   {
53928     try {
53929       (arg1)->Emit();
53930     } catch (std::out_of_range& e) {
53931       {
53932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53933       };
53934     } catch (std::exception& e) {
53935       {
53936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53937       };
53938     } catch (Dali::DaliException e) {
53939       {
53940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53941       };
53942     } catch (...) {
53943       {
53944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53945       };
53946     }
53947   }
53948
53949 }
53950
53951
53952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53953   unsigned int jresult ;
53954   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53955   bool result;
53956
53957   arg1 = (Dali::Signal< void (float) > *)jarg1;
53958   {
53959     try {
53960       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53961     } catch (std::out_of_range& e) {
53962       {
53963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53964       };
53965     } catch (std::exception& e) {
53966       {
53967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53968       };
53969     } catch (Dali::DaliException e) {
53970       {
53971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53972       };
53973     } catch (...) {
53974       {
53975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53976       };
53977     }
53978   }
53979
53980   jresult = result;
53981   return jresult;
53982 }
53983
53984
53985 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53986   unsigned long jresult ;
53987   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53988   std::size_t result;
53989
53990   arg1 = (Dali::Signal< void (float) > *)jarg1;
53991   {
53992     try {
53993       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53994     } catch (std::out_of_range& e) {
53995       {
53996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53997       };
53998     } catch (std::exception& e) {
53999       {
54000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54001       };
54002     } catch (Dali::DaliException e) {
54003       {
54004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54005       };
54006     } catch (...) {
54007       {
54008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54009       };
54010     }
54011   }
54012
54013   jresult = (unsigned long)result;
54014   return jresult;
54015 }
54016
54017
54018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
54019   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54020   void (*arg2)(float) = (void (*)(float)) 0 ;
54021
54022   arg1 = (Dali::Signal< void (float) > *)jarg1;
54023   arg2 = (void (*)(float))jarg2;
54024   {
54025     try {
54026       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
54027     } catch (std::out_of_range& e) {
54028       {
54029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54030       };
54031     } catch (std::exception& e) {
54032       {
54033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54034       };
54035     } catch (Dali::DaliException e) {
54036       {
54037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54038       };
54039     } catch (...) {
54040       {
54041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54042       };
54043     }
54044   }
54045
54046 }
54047
54048
54049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
54050   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54051   void (*arg2)(float) = (void (*)(float)) 0 ;
54052
54053   arg1 = (Dali::Signal< void (float) > *)jarg1;
54054   arg2 = (void (*)(float))jarg2;
54055   {
54056     try {
54057       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
54058     } catch (std::out_of_range& e) {
54059       {
54060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54061       };
54062     } catch (std::exception& e) {
54063       {
54064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54065       };
54066     } catch (Dali::DaliException e) {
54067       {
54068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54069       };
54070     } catch (...) {
54071       {
54072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54073       };
54074     }
54075   }
54076
54077 }
54078
54079
54080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
54081   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54082   float arg2 ;
54083
54084   arg1 = (Dali::Signal< void (float) > *)jarg1;
54085   arg2 = (float)jarg2;
54086   {
54087     try {
54088       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54089     } catch (std::out_of_range& e) {
54090       {
54091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54092       };
54093     } catch (std::exception& e) {
54094       {
54095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54096       };
54097     } catch (Dali::DaliException e) {
54098       {
54099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54100       };
54101     } catch (...) {
54102       {
54103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54104       };
54105     }
54106   }
54107
54108 }
54109
54110
54111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54112   void * jresult ;
54113   Dali::Signal< void (float) > *result = 0 ;
54114
54115   {
54116     try {
54117       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54118     } catch (std::out_of_range& e) {
54119       {
54120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54121       };
54122     } catch (std::exception& e) {
54123       {
54124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54125       };
54126     } catch (Dali::DaliException e) {
54127       {
54128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54129       };
54130     } catch (...) {
54131       {
54132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54133       };
54134     }
54135   }
54136
54137   jresult = (void *)result;
54138   return jresult;
54139 }
54140
54141
54142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54143   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54144
54145   arg1 = (Dali::Signal< void (float) > *)jarg1;
54146   {
54147     try {
54148       delete arg1;
54149     } catch (std::out_of_range& e) {
54150       {
54151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54152       };
54153     } catch (std::exception& e) {
54154       {
54155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54156       };
54157     } catch (Dali::DaliException e) {
54158       {
54159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54160       };
54161     } catch (...) {
54162       {
54163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54164       };
54165     }
54166   }
54167
54168 }
54169
54170
54171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54172   unsigned int jresult ;
54173   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54174   bool result;
54175
54176   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54177   {
54178     try {
54179       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54180     } catch (std::out_of_range& e) {
54181       {
54182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54183       };
54184     } catch (std::exception& e) {
54185       {
54186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54187       };
54188     } catch (Dali::DaliException e) {
54189       {
54190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54191       };
54192     } catch (...) {
54193       {
54194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54195       };
54196     }
54197   }
54198
54199   jresult = result;
54200   return jresult;
54201 }
54202
54203
54204 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54205   unsigned long jresult ;
54206   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54207   std::size_t result;
54208
54209   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54210   {
54211     try {
54212       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54213     } catch (std::out_of_range& e) {
54214       {
54215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54216       };
54217     } catch (std::exception& e) {
54218       {
54219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54220       };
54221     } catch (Dali::DaliException e) {
54222       {
54223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54224       };
54225     } catch (...) {
54226       {
54227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54228       };
54229     }
54230   }
54231
54232   jresult = (unsigned long)result;
54233   return jresult;
54234 }
54235
54236
54237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54238   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54239   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54240
54241   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54242   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54243   {
54244     try {
54245       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54246     } catch (std::out_of_range& e) {
54247       {
54248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54249       };
54250     } catch (std::exception& e) {
54251       {
54252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54253       };
54254     } catch (Dali::DaliException e) {
54255       {
54256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54257       };
54258     } catch (...) {
54259       {
54260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54261       };
54262     }
54263   }
54264
54265 }
54266
54267
54268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54269   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54270   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54271
54272   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54273   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54274   {
54275     try {
54276       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54277     } catch (std::out_of_range& e) {
54278       {
54279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54280       };
54281     } catch (std::exception& e) {
54282       {
54283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54284       };
54285     } catch (Dali::DaliException e) {
54286       {
54287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54288       };
54289     } catch (...) {
54290       {
54291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54292       };
54293     }
54294   }
54295
54296 }
54297
54298
54299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54300   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54301   Dali::BaseHandle arg2 ;
54302   Dali::BaseHandle *argp2 ;
54303
54304   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54305   argp2 = (Dali::BaseHandle *)jarg2;
54306   if (!argp2) {
54307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54308     return ;
54309   }
54310   arg2 = *argp2;
54311   {
54312     try {
54313       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54314     } catch (std::out_of_range& e) {
54315       {
54316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54317       };
54318     } catch (std::exception& e) {
54319       {
54320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54321       };
54322     } catch (Dali::DaliException e) {
54323       {
54324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54325       };
54326     } catch (...) {
54327       {
54328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54329       };
54330     }
54331   }
54332
54333 }
54334
54335
54336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54337   void * jresult ;
54338   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54339
54340   {
54341     try {
54342       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54343     } catch (std::out_of_range& e) {
54344       {
54345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54346       };
54347     } catch (std::exception& e) {
54348       {
54349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54350       };
54351     } catch (Dali::DaliException e) {
54352       {
54353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54354       };
54355     } catch (...) {
54356       {
54357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54358       };
54359     }
54360   }
54361
54362   jresult = (void *)result;
54363   return jresult;
54364 }
54365
54366
54367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54368   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54369
54370   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54371   {
54372     try {
54373       delete arg1;
54374     } catch (std::out_of_range& e) {
54375       {
54376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54377       };
54378     } catch (std::exception& e) {
54379       {
54380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54381       };
54382     } catch (Dali::DaliException e) {
54383       {
54384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54385       };
54386     } catch (...) {
54387       {
54388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54389       };
54390     }
54391   }
54392
54393 }
54394
54395
54396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54397   unsigned int jresult ;
54398   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54399   bool result;
54400
54401   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54402   {
54403     try {
54404       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54405     } catch (std::out_of_range& e) {
54406       {
54407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54408       };
54409     } catch (std::exception& e) {
54410       {
54411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54412       };
54413     } catch (Dali::DaliException e) {
54414       {
54415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54416       };
54417     } catch (...) {
54418       {
54419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54420       };
54421     }
54422   }
54423
54424   jresult = result;
54425   return jresult;
54426 }
54427
54428
54429 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54430   unsigned long jresult ;
54431   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54432   std::size_t result;
54433
54434   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54435   {
54436     try {
54437       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54438     } catch (std::out_of_range& e) {
54439       {
54440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54441       };
54442     } catch (std::exception& e) {
54443       {
54444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54445       };
54446     } catch (Dali::DaliException e) {
54447       {
54448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54449       };
54450     } catch (...) {
54451       {
54452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54453       };
54454     }
54455   }
54456
54457   jresult = (unsigned long)result;
54458   return jresult;
54459 }
54460
54461
54462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54463   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54464   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54465
54466   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54467   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54468   {
54469     try {
54470       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54471     } catch (std::out_of_range& e) {
54472       {
54473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54474       };
54475     } catch (std::exception& e) {
54476       {
54477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54478       };
54479     } catch (Dali::DaliException e) {
54480       {
54481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54482       };
54483     } catch (...) {
54484       {
54485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54486       };
54487     }
54488   }
54489
54490 }
54491
54492
54493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54494   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54495   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54496
54497   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54498   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54499   {
54500     try {
54501       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54502     } catch (std::out_of_range& e) {
54503       {
54504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54505       };
54506     } catch (std::exception& e) {
54507       {
54508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54509       };
54510     } catch (Dali::DaliException e) {
54511       {
54512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54513       };
54514     } catch (...) {
54515       {
54516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54517       };
54518     }
54519   }
54520
54521 }
54522
54523
54524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54525   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54526   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54527
54528   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54529   arg2 = (Dali::RefObject *)jarg2;
54530   {
54531     try {
54532       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54533     } catch (std::out_of_range& e) {
54534       {
54535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54536       };
54537     } catch (std::exception& e) {
54538       {
54539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54540       };
54541     } catch (Dali::DaliException e) {
54542       {
54543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54544       };
54545     } catch (...) {
54546       {
54547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54548       };
54549     }
54550   }
54551
54552 }
54553
54554
54555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54556   void * jresult ;
54557   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54558
54559   {
54560     try {
54561       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54562     } catch (std::out_of_range& e) {
54563       {
54564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54565       };
54566     } catch (std::exception& e) {
54567       {
54568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54569       };
54570     } catch (Dali::DaliException e) {
54571       {
54572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54573       };
54574     } catch (...) {
54575       {
54576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54577       };
54578     }
54579   }
54580
54581   jresult = (void *)result;
54582   return jresult;
54583 }
54584
54585
54586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54587   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54588
54589   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54590   {
54591     try {
54592       delete arg1;
54593     } catch (std::out_of_range& e) {
54594       {
54595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54596       };
54597     } catch (std::exception& e) {
54598       {
54599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54600       };
54601     } catch (Dali::DaliException e) {
54602       {
54603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54604       };
54605     } catch (...) {
54606       {
54607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54608       };
54609     }
54610   }
54611
54612 }
54613
54614
54615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54616   unsigned int jresult ;
54617   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54618   bool result;
54619
54620   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54621   {
54622     try {
54623       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54624     } catch (std::out_of_range& e) {
54625       {
54626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54627       };
54628     } catch (std::exception& e) {
54629       {
54630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54631       };
54632     } catch (Dali::DaliException e) {
54633       {
54634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54635       };
54636     } catch (...) {
54637       {
54638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54639       };
54640     }
54641   }
54642
54643   jresult = result;
54644   return jresult;
54645 }
54646
54647
54648 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54649   unsigned long jresult ;
54650   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54651   std::size_t result;
54652
54653   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54654   {
54655     try {
54656       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54657     } catch (std::out_of_range& e) {
54658       {
54659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54660       };
54661     } catch (std::exception& e) {
54662       {
54663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54664       };
54665     } catch (Dali::DaliException e) {
54666       {
54667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54668       };
54669     } catch (...) {
54670       {
54671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54672       };
54673     }
54674   }
54675
54676   jresult = (unsigned long)result;
54677   return jresult;
54678 }
54679
54680
54681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54682   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54683   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54684
54685   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54686   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54687   {
54688     try {
54689       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54690     } catch (std::out_of_range& e) {
54691       {
54692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54693       };
54694     } catch (std::exception& e) {
54695       {
54696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54697       };
54698     } catch (Dali::DaliException e) {
54699       {
54700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54701       };
54702     } catch (...) {
54703       {
54704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54705       };
54706     }
54707   }
54708
54709 }
54710
54711
54712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54713   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54714   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54715
54716   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54717   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54718   {
54719     try {
54720       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54721     } catch (std::out_of_range& e) {
54722       {
54723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54724       };
54725     } catch (std::exception& e) {
54726       {
54727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54728       };
54729     } catch (Dali::DaliException e) {
54730       {
54731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54732       };
54733     } catch (...) {
54734       {
54735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54736       };
54737     }
54738   }
54739
54740 }
54741
54742
54743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54744   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54745   Dali::PropertyNotification *arg2 = 0 ;
54746
54747   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54748   arg2 = (Dali::PropertyNotification *)jarg2;
54749   if (!arg2) {
54750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54751     return ;
54752   }
54753   {
54754     try {
54755       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54756     } catch (std::out_of_range& e) {
54757       {
54758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54759       };
54760     } catch (std::exception& e) {
54761       {
54762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54763       };
54764     } catch (Dali::DaliException e) {
54765       {
54766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54767       };
54768     } catch (...) {
54769       {
54770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54771       };
54772     }
54773   }
54774
54775 }
54776
54777
54778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54779   void * jresult ;
54780   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54781
54782   {
54783     try {
54784       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54785     } catch (std::out_of_range& e) {
54786       {
54787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54788       };
54789     } catch (std::exception& e) {
54790       {
54791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54792       };
54793     } catch (Dali::DaliException e) {
54794       {
54795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54796       };
54797     } catch (...) {
54798       {
54799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54800       };
54801     }
54802   }
54803
54804   jresult = (void *)result;
54805   return jresult;
54806 }
54807
54808
54809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54810   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54811
54812   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54813   {
54814     try {
54815       delete arg1;
54816     } catch (std::out_of_range& e) {
54817       {
54818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54819       };
54820     } catch (std::exception& e) {
54821       {
54822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54823       };
54824     } catch (Dali::DaliException e) {
54825       {
54826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54827       };
54828     } catch (...) {
54829       {
54830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54831       };
54832     }
54833   }
54834
54835 }
54836
54837
54838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54839   unsigned int jresult ;
54840   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54841   bool result;
54842
54843   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54844   {
54845     try {
54846       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54847     } catch (std::out_of_range& e) {
54848       {
54849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54850       };
54851     } catch (std::exception& e) {
54852       {
54853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54854       };
54855     } catch (Dali::DaliException e) {
54856       {
54857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54858       };
54859     } catch (...) {
54860       {
54861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54862       };
54863     }
54864   }
54865
54866   jresult = result;
54867   return jresult;
54868 }
54869
54870
54871 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54872   unsigned long jresult ;
54873   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54874   std::size_t result;
54875
54876   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54877   {
54878     try {
54879       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54880     } catch (std::out_of_range& e) {
54881       {
54882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54883       };
54884     } catch (std::exception& e) {
54885       {
54886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54887       };
54888     } catch (Dali::DaliException e) {
54889       {
54890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54891       };
54892     } catch (...) {
54893       {
54894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54895       };
54896     }
54897   }
54898
54899   jresult = (unsigned long)result;
54900   return jresult;
54901 }
54902
54903
54904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54905   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54906   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54907
54908   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54909   arg2 = (void (*)(Dali::Image))jarg2;
54910   {
54911     try {
54912       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54913     } catch (std::out_of_range& e) {
54914       {
54915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54916       };
54917     } catch (std::exception& e) {
54918       {
54919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54920       };
54921     } catch (Dali::DaliException e) {
54922       {
54923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54924       };
54925     } catch (...) {
54926       {
54927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54928       };
54929     }
54930   }
54931
54932 }
54933
54934
54935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54936   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54937   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54938
54939   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54940   arg2 = (void (*)(Dali::Image))jarg2;
54941   {
54942     try {
54943       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54944     } catch (std::out_of_range& e) {
54945       {
54946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54947       };
54948     } catch (std::exception& e) {
54949       {
54950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54951       };
54952     } catch (Dali::DaliException e) {
54953       {
54954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54955       };
54956     } catch (...) {
54957       {
54958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54959       };
54960     }
54961   }
54962
54963 }
54964
54965
54966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54967   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54968   Dali::Image arg2 ;
54969   Dali::Image *argp2 ;
54970
54971   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54972   argp2 = (Dali::Image *)jarg2;
54973   if (!argp2) {
54974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54975     return ;
54976   }
54977   arg2 = *argp2;
54978   {
54979     try {
54980       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54981     } catch (std::out_of_range& e) {
54982       {
54983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54984       };
54985     } catch (std::exception& e) {
54986       {
54987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54988       };
54989     } catch (Dali::DaliException e) {
54990       {
54991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54992       };
54993     } catch (...) {
54994       {
54995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54996       };
54997     }
54998   }
54999
55000 }
55001
55002
55003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
55004   void * jresult ;
55005   Dali::Signal< void (Dali::Image) > *result = 0 ;
55006
55007   {
55008     try {
55009       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
55010     } catch (std::out_of_range& e) {
55011       {
55012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55013       };
55014     } catch (std::exception& e) {
55015       {
55016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55017       };
55018     } catch (Dali::DaliException e) {
55019       {
55020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55021       };
55022     } catch (...) {
55023       {
55024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55025       };
55026     }
55027   }
55028
55029   jresult = (void *)result;
55030   return jresult;
55031 }
55032
55033
55034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
55035   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55036
55037   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55038   {
55039     try {
55040       delete arg1;
55041     } catch (std::out_of_range& e) {
55042       {
55043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55044       };
55045     } catch (std::exception& e) {
55046       {
55047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55048       };
55049     } catch (Dali::DaliException e) {
55050       {
55051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55052       };
55053     } catch (...) {
55054       {
55055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55056       };
55057     }
55058   }
55059
55060 }
55061
55062
55063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
55064   void * jresult ;
55065   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
55066
55067   {
55068     try {
55069       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
55070     } catch (std::out_of_range& e) {
55071       {
55072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55073       };
55074     } catch (std::exception& e) {
55075       {
55076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55077       };
55078     } catch (Dali::DaliException e) {
55079       {
55080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55081       };
55082     } catch (...) {
55083       {
55084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55085       };
55086     }
55087   }
55088
55089   jresult = (void *)result;
55090   return jresult;
55091 }
55092
55093
55094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55095   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55096
55097   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55098   {
55099     try {
55100       delete arg1;
55101     } catch (std::out_of_range& e) {
55102       {
55103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55104       };
55105     } catch (std::exception& e) {
55106       {
55107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55108       };
55109     } catch (Dali::DaliException e) {
55110       {
55111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55112       };
55113     } catch (...) {
55114       {
55115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55116       };
55117     }
55118   }
55119
55120 }
55121
55122
55123 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55124   unsigned int jresult ;
55125   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55126   bool result;
55127
55128   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55129   {
55130     try {
55131       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
55132     } catch (std::out_of_range& e) {
55133       {
55134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55135       };
55136     } catch (std::exception& e) {
55137       {
55138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55139       };
55140     } catch (Dali::DaliException e) {
55141       {
55142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55143       };
55144     } catch (...) {
55145       {
55146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55147       };
55148     }
55149   }
55150
55151   jresult = result;
55152   return jresult;
55153 }
55154
55155
55156 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55157   unsigned long jresult ;
55158   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55159   std::size_t result;
55160
55161   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55162   {
55163     try {
55164       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
55165     } catch (std::out_of_range& e) {
55166       {
55167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55168       };
55169     } catch (std::exception& e) {
55170       {
55171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55172       };
55173     } catch (Dali::DaliException e) {
55174       {
55175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55176       };
55177     } catch (...) {
55178       {
55179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55180       };
55181     }
55182   }
55183
55184   jresult = (unsigned long)result;
55185   return jresult;
55186 }
55187
55188
55189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55190   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55191   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55192
55193   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55194   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55195   {
55196     try {
55197       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55198     } catch (std::out_of_range& e) {
55199       {
55200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55201       };
55202     } catch (std::exception& e) {
55203       {
55204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55205       };
55206     } catch (Dali::DaliException e) {
55207       {
55208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55209       };
55210     } catch (...) {
55211       {
55212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55213       };
55214     }
55215   }
55216
55217 }
55218
55219
55220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55221   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55222   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55223
55224   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55225   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55226   {
55227     try {
55228       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55229     } catch (std::out_of_range& e) {
55230       {
55231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55232       };
55233     } catch (std::exception& e) {
55234       {
55235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55236       };
55237     } catch (Dali::DaliException e) {
55238       {
55239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55240       };
55241     } catch (...) {
55242       {
55243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55244       };
55245     }
55246   }
55247
55248 }
55249
55250
55251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55252   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55253   Dali::Actor arg2 ;
55254   Dali::LongPressGesture *arg3 = 0 ;
55255   Dali::Actor *argp2 ;
55256
55257   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55258   argp2 = (Dali::Actor *)jarg2;
55259   if (!argp2) {
55260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55261     return ;
55262   }
55263   arg2 = *argp2;
55264   arg3 = (Dali::LongPressGesture *)jarg3;
55265   if (!arg3) {
55266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55267     return ;
55268   }
55269   {
55270     try {
55271       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55272     } catch (std::out_of_range& e) {
55273       {
55274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55275       };
55276     } catch (std::exception& e) {
55277       {
55278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55279       };
55280     } catch (Dali::DaliException e) {
55281       {
55282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55283       };
55284     } catch (...) {
55285       {
55286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55287       };
55288     }
55289   }
55290
55291 }
55292
55293
55294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55295   void * jresult ;
55296   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55297
55298   {
55299     try {
55300       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55301     } catch (std::out_of_range& e) {
55302       {
55303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55304       };
55305     } catch (std::exception& e) {
55306       {
55307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55308       };
55309     } catch (Dali::DaliException e) {
55310       {
55311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55312       };
55313     } catch (...) {
55314       {
55315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55316       };
55317     }
55318   }
55319
55320   jresult = (void *)result;
55321   return jresult;
55322 }
55323
55324
55325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55326   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55327
55328   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55329   {
55330     try {
55331       delete arg1;
55332     } catch (std::out_of_range& e) {
55333       {
55334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55335       };
55336     } catch (std::exception& e) {
55337       {
55338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55339       };
55340     } catch (Dali::DaliException e) {
55341       {
55342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55343       };
55344     } catch (...) {
55345       {
55346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55347       };
55348     }
55349   }
55350
55351 }
55352
55353
55354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55355   unsigned int jresult ;
55356   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55357   bool result;
55358
55359   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55360   {
55361     try {
55362       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *)arg1);
55363     } catch (std::out_of_range& e) {
55364       {
55365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55366       };
55367     } catch (std::exception& e) {
55368       {
55369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55370       };
55371     } catch (Dali::DaliException e) {
55372       {
55373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55374       };
55375     } catch (...) {
55376       {
55377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55378       };
55379     }
55380   }
55381
55382   jresult = result;
55383   return jresult;
55384 }
55385
55386
55387 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55388   unsigned long jresult ;
55389   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55390   std::size_t result;
55391
55392   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55393   {
55394     try {
55395       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *)arg1);
55396     } catch (std::out_of_range& e) {
55397       {
55398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55399       };
55400     } catch (std::exception& e) {
55401       {
55402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55403       };
55404     } catch (Dali::DaliException e) {
55405       {
55406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55407       };
55408     } catch (...) {
55409       {
55410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55411       };
55412     }
55413   }
55414
55415   jresult = (unsigned long)result;
55416   return jresult;
55417 }
55418
55419
55420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55421   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55422   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55423
55424   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55425   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55426   {
55427     try {
55428       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55429     } catch (std::out_of_range& e) {
55430       {
55431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55432       };
55433     } catch (std::exception& e) {
55434       {
55435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55436       };
55437     } catch (Dali::DaliException e) {
55438       {
55439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55440       };
55441     } catch (...) {
55442       {
55443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55444       };
55445     }
55446   }
55447
55448 }
55449
55450
55451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55452   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55453   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55454
55455   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55456   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55457   {
55458     try {
55459       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55460     } catch (std::out_of_range& e) {
55461       {
55462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55463       };
55464     } catch (std::exception& e) {
55465       {
55466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55467       };
55468     } catch (Dali::DaliException e) {
55469       {
55470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55471       };
55472     } catch (...) {
55473       {
55474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55475       };
55476     }
55477   }
55478
55479 }
55480
55481
55482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55483   unsigned int jresult ;
55484   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55485   Dali::Actor arg2 ;
55486   Dali::TouchData *arg3 = 0 ;
55487   Dali::Actor *argp2 ;
55488   bool result;
55489
55490   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55491   argp2 = (Dali::Actor *)jarg2;
55492   if (!argp2) {
55493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55494     return 0;
55495   }
55496   arg2 = *argp2;
55497   arg3 = (Dali::TouchData *)jarg3;
55498   if (!arg3) {
55499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55500     return 0;
55501   }
55502   {
55503     try {
55504       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55505     } catch (std::out_of_range& e) {
55506       {
55507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55508       };
55509     } catch (std::exception& e) {
55510       {
55511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55512       };
55513     } catch (Dali::DaliException e) {
55514       {
55515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55516       };
55517     } catch (...) {
55518       {
55519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55520       };
55521     }
55522   }
55523
55524   jresult = result;
55525   return jresult;
55526 }
55527
55528
55529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55530   void * jresult ;
55531   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55532
55533   {
55534     try {
55535       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55536     } catch (std::out_of_range& e) {
55537       {
55538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55539       };
55540     } catch (std::exception& e) {
55541       {
55542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55543       };
55544     } catch (Dali::DaliException e) {
55545       {
55546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55547       };
55548     } catch (...) {
55549       {
55550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55551       };
55552     }
55553   }
55554
55555   jresult = (void *)result;
55556   return jresult;
55557 }
55558
55559
55560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55561   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55562
55563   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55564   {
55565     try {
55566       delete arg1;
55567     } catch (std::out_of_range& e) {
55568       {
55569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55570       };
55571     } catch (std::exception& e) {
55572       {
55573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55574       };
55575     } catch (Dali::DaliException e) {
55576       {
55577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55578       };
55579     } catch (...) {
55580       {
55581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55582       };
55583     }
55584   }
55585
55586 }
55587
55588
55589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55590   unsigned int jresult ;
55591   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55592   bool result;
55593
55594   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55595   {
55596     try {
55597       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *)arg1);
55598     } catch (std::out_of_range& e) {
55599       {
55600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55601       };
55602     } catch (std::exception& e) {
55603       {
55604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55605       };
55606     } catch (Dali::DaliException e) {
55607       {
55608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55609       };
55610     } catch (...) {
55611       {
55612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55613       };
55614     }
55615   }
55616
55617   jresult = result;
55618   return jresult;
55619 }
55620
55621
55622 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55623   unsigned long jresult ;
55624   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55625   std::size_t result;
55626
55627   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55628   {
55629     try {
55630       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *)arg1);
55631     } catch (std::out_of_range& e) {
55632       {
55633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55634       };
55635     } catch (std::exception& e) {
55636       {
55637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55638       };
55639     } catch (Dali::DaliException e) {
55640       {
55641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55642       };
55643     } catch (...) {
55644       {
55645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55646       };
55647     }
55648   }
55649
55650   jresult = (unsigned long)result;
55651   return jresult;
55652 }
55653
55654
55655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55656   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55657   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55658
55659   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55660   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55661   {
55662     try {
55663       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55664     } catch (std::out_of_range& e) {
55665       {
55666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55667       };
55668     } catch (std::exception& e) {
55669       {
55670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55671       };
55672     } catch (Dali::DaliException e) {
55673       {
55674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55675       };
55676     } catch (...) {
55677       {
55678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55679       };
55680     }
55681   }
55682
55683 }
55684
55685
55686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55687   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55688   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55689
55690   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55691   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55692   {
55693     try {
55694       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55695     } catch (std::out_of_range& e) {
55696       {
55697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55698       };
55699     } catch (std::exception& e) {
55700       {
55701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55702       };
55703     } catch (Dali::DaliException e) {
55704       {
55705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55706       };
55707     } catch (...) {
55708       {
55709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55710       };
55711     }
55712   }
55713
55714 }
55715
55716
55717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55718   unsigned int jresult ;
55719   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55720   Dali::Actor arg2 ;
55721   Dali::HoverEvent *arg3 = 0 ;
55722   Dali::Actor *argp2 ;
55723   bool result;
55724
55725   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55726   argp2 = (Dali::Actor *)jarg2;
55727   if (!argp2) {
55728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55729     return 0;
55730   }
55731   arg2 = *argp2;
55732   arg3 = (Dali::HoverEvent *)jarg3;
55733   if (!arg3) {
55734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55735     return 0;
55736   }
55737   {
55738     try {
55739       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55740     } catch (std::out_of_range& e) {
55741       {
55742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55743       };
55744     } catch (std::exception& e) {
55745       {
55746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55747       };
55748     } catch (Dali::DaliException e) {
55749       {
55750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55751       };
55752     } catch (...) {
55753       {
55754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55755       };
55756     }
55757   }
55758
55759   jresult = result;
55760   return jresult;
55761 }
55762
55763
55764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55765   void * jresult ;
55766   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55767
55768   {
55769     try {
55770       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55771     } catch (std::out_of_range& e) {
55772       {
55773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55774       };
55775     } catch (std::exception& e) {
55776       {
55777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55778       };
55779     } catch (Dali::DaliException e) {
55780       {
55781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55782       };
55783     } catch (...) {
55784       {
55785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55786       };
55787     }
55788   }
55789
55790   jresult = (void *)result;
55791   return jresult;
55792 }
55793
55794
55795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55796   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55797
55798   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55799   {
55800     try {
55801       delete arg1;
55802     } catch (std::out_of_range& e) {
55803       {
55804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55805       };
55806     } catch (std::exception& e) {
55807       {
55808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55809       };
55810     } catch (Dali::DaliException e) {
55811       {
55812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55813       };
55814     } catch (...) {
55815       {
55816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55817       };
55818     }
55819   }
55820
55821 }
55822
55823
55824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55825   unsigned int jresult ;
55826   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55827   bool result;
55828
55829   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55830   {
55831     try {
55832       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *)arg1);
55833     } catch (std::out_of_range& e) {
55834       {
55835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55836       };
55837     } catch (std::exception& e) {
55838       {
55839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55840       };
55841     } catch (Dali::DaliException e) {
55842       {
55843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55844       };
55845     } catch (...) {
55846       {
55847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55848       };
55849     }
55850   }
55851
55852   jresult = result;
55853   return jresult;
55854 }
55855
55856
55857 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55858   unsigned long jresult ;
55859   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55860   std::size_t result;
55861
55862   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55863   {
55864     try {
55865       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *)arg1);
55866     } catch (std::out_of_range& e) {
55867       {
55868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55869       };
55870     } catch (std::exception& e) {
55871       {
55872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55873       };
55874     } catch (Dali::DaliException e) {
55875       {
55876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55877       };
55878     } catch (...) {
55879       {
55880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55881       };
55882     }
55883   }
55884
55885   jresult = (unsigned long)result;
55886   return jresult;
55887 }
55888
55889
55890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55891   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55892   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55893
55894   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55895   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55896   {
55897     try {
55898       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55899     } catch (std::out_of_range& e) {
55900       {
55901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55902       };
55903     } catch (std::exception& e) {
55904       {
55905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55906       };
55907     } catch (Dali::DaliException e) {
55908       {
55909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55910       };
55911     } catch (...) {
55912       {
55913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55914       };
55915     }
55916   }
55917
55918 }
55919
55920
55921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55922   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55923   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55924
55925   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55926   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55927   {
55928     try {
55929       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55930     } catch (std::out_of_range& e) {
55931       {
55932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55933       };
55934     } catch (std::exception& e) {
55935       {
55936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55937       };
55938     } catch (Dali::DaliException e) {
55939       {
55940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55941       };
55942     } catch (...) {
55943       {
55944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55945       };
55946     }
55947   }
55948
55949 }
55950
55951
55952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55953   unsigned int jresult ;
55954   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55955   Dali::Actor arg2 ;
55956   Dali::WheelEvent *arg3 = 0 ;
55957   Dali::Actor *argp2 ;
55958   bool result;
55959
55960   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55961   argp2 = (Dali::Actor *)jarg2;
55962   if (!argp2) {
55963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55964     return 0;
55965   }
55966   arg2 = *argp2;
55967   arg3 = (Dali::WheelEvent *)jarg3;
55968   if (!arg3) {
55969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55970     return 0;
55971   }
55972   {
55973     try {
55974       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55975     } catch (std::out_of_range& e) {
55976       {
55977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55978       };
55979     } catch (std::exception& e) {
55980       {
55981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55982       };
55983     } catch (Dali::DaliException e) {
55984       {
55985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55986       };
55987     } catch (...) {
55988       {
55989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55990       };
55991     }
55992   }
55993
55994   jresult = result;
55995   return jresult;
55996 }
55997
55998
55999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
56000   void * jresult ;
56001   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
56002
56003   {
56004     try {
56005       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
56006     } catch (std::out_of_range& e) {
56007       {
56008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56009       };
56010     } catch (std::exception& e) {
56011       {
56012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56013       };
56014     } catch (Dali::DaliException e) {
56015       {
56016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56017       };
56018     } catch (...) {
56019       {
56020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56021       };
56022     }
56023   }
56024
56025   jresult = (void *)result;
56026   return jresult;
56027 }
56028
56029
56030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
56031   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
56032
56033   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
56034   {
56035     try {
56036       delete arg1;
56037     } catch (std::out_of_range& e) {
56038       {
56039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56040       };
56041     } catch (std::exception& e) {
56042       {
56043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56044       };
56045     } catch (Dali::DaliException e) {
56046       {
56047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56048       };
56049     } catch (...) {
56050       {
56051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56052       };
56053     }
56054   }
56055
56056 }
56057
56058
56059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
56060   unsigned int jresult ;
56061   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56062   bool result;
56063
56064   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56065   {
56066     try {
56067       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
56068     } catch (std::out_of_range& e) {
56069       {
56070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56071       };
56072     } catch (std::exception& e) {
56073       {
56074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56075       };
56076     } catch (Dali::DaliException e) {
56077       {
56078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56079       };
56080     } catch (...) {
56081       {
56082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56083       };
56084     }
56085   }
56086
56087   jresult = result;
56088   return jresult;
56089 }
56090
56091
56092 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56093   unsigned long jresult ;
56094   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56095   std::size_t result;
56096
56097   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56098   {
56099     try {
56100       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56101     } catch (std::out_of_range& e) {
56102       {
56103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56104       };
56105     } catch (std::exception& e) {
56106       {
56107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56108       };
56109     } catch (Dali::DaliException e) {
56110       {
56111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56112       };
56113     } catch (...) {
56114       {
56115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56116       };
56117     }
56118   }
56119
56120   jresult = (unsigned long)result;
56121   return jresult;
56122 }
56123
56124
56125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56126   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56127   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56128
56129   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56130   arg2 = (void (*)(Dali::Actor))jarg2;
56131   {
56132     try {
56133       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56134     } catch (std::out_of_range& e) {
56135       {
56136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56137       };
56138     } catch (std::exception& e) {
56139       {
56140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56141       };
56142     } catch (Dali::DaliException e) {
56143       {
56144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56145       };
56146     } catch (...) {
56147       {
56148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56149       };
56150     }
56151   }
56152
56153 }
56154
56155
56156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56157   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56158   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56159
56160   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56161   arg2 = (void (*)(Dali::Actor))jarg2;
56162   {
56163     try {
56164       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56165     } catch (std::out_of_range& e) {
56166       {
56167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56168       };
56169     } catch (std::exception& e) {
56170       {
56171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56172       };
56173     } catch (Dali::DaliException e) {
56174       {
56175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56176       };
56177     } catch (...) {
56178       {
56179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56180       };
56181     }
56182   }
56183
56184 }
56185
56186
56187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56188   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56189   Dali::Actor arg2 ;
56190   Dali::Actor *argp2 ;
56191
56192   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56193   argp2 = (Dali::Actor *)jarg2;
56194   if (!argp2) {
56195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56196     return ;
56197   }
56198   arg2 = *argp2;
56199   {
56200     try {
56201       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56202     } catch (std::out_of_range& e) {
56203       {
56204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56205       };
56206     } catch (std::exception& e) {
56207       {
56208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56209       };
56210     } catch (Dali::DaliException e) {
56211       {
56212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56213       };
56214     } catch (...) {
56215       {
56216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56217       };
56218     }
56219   }
56220
56221 }
56222
56223
56224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56225   void * jresult ;
56226   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56227
56228   {
56229     try {
56230       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56231     } catch (std::out_of_range& e) {
56232       {
56233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56234       };
56235     } catch (std::exception& e) {
56236       {
56237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56238       };
56239     } catch (Dali::DaliException e) {
56240       {
56241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56242       };
56243     } catch (...) {
56244       {
56245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56246       };
56247     }
56248   }
56249
56250   jresult = (void *)result;
56251   return jresult;
56252 }
56253
56254
56255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56256   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56257
56258   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56259   {
56260     try {
56261       delete arg1;
56262     } catch (std::out_of_range& e) {
56263       {
56264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56265       };
56266     } catch (std::exception& e) {
56267       {
56268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56269       };
56270     } catch (Dali::DaliException e) {
56271       {
56272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56273       };
56274     } catch (...) {
56275       {
56276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56277       };
56278     }
56279   }
56280
56281 }
56282
56283
56284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56285   unsigned int jresult ;
56286   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56287   bool result;
56288
56289   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56290   {
56291     try {
56292       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56293     } catch (std::out_of_range& e) {
56294       {
56295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56296       };
56297     } catch (std::exception& e) {
56298       {
56299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56300       };
56301     } catch (Dali::DaliException e) {
56302       {
56303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56304       };
56305     } catch (...) {
56306       {
56307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56308       };
56309     }
56310   }
56311
56312   jresult = result;
56313   return jresult;
56314 }
56315
56316
56317 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56318   unsigned long jresult ;
56319   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56320   std::size_t result;
56321
56322   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56323   {
56324     try {
56325       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56326     } catch (std::out_of_range& e) {
56327       {
56328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56329       };
56330     } catch (std::exception& e) {
56331       {
56332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56333       };
56334     } catch (Dali::DaliException e) {
56335       {
56336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56337       };
56338     } catch (...) {
56339       {
56340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56341       };
56342     }
56343   }
56344
56345   jresult = (unsigned long)result;
56346   return jresult;
56347 }
56348
56349
56350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56351   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56352   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56353
56354   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56355   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56356   {
56357     try {
56358       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56359     } catch (std::out_of_range& e) {
56360       {
56361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56362       };
56363     } catch (std::exception& e) {
56364       {
56365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56366       };
56367     } catch (Dali::DaliException e) {
56368       {
56369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56370       };
56371     } catch (...) {
56372       {
56373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56374       };
56375     }
56376   }
56377
56378 }
56379
56380
56381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56382   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56383   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56384
56385   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56386   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56387   {
56388     try {
56389       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56390     } catch (std::out_of_range& e) {
56391       {
56392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56393       };
56394     } catch (std::exception& e) {
56395       {
56396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56397       };
56398     } catch (Dali::DaliException e) {
56399       {
56400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56401       };
56402     } catch (...) {
56403       {
56404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56405       };
56406     }
56407   }
56408
56409 }
56410
56411
56412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56413   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56414   Dali::KeyEvent *arg2 = 0 ;
56415
56416   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56417   arg2 = (Dali::KeyEvent *)jarg2;
56418   if (!arg2) {
56419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56420     return ;
56421   }
56422   {
56423     try {
56424       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56425     } catch (std::out_of_range& e) {
56426       {
56427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56428       };
56429     } catch (std::exception& e) {
56430       {
56431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56432       };
56433     } catch (Dali::DaliException e) {
56434       {
56435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56436       };
56437     } catch (...) {
56438       {
56439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56440       };
56441     }
56442   }
56443
56444 }
56445
56446
56447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56448   void * jresult ;
56449   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56450
56451   {
56452     try {
56453       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56454     } catch (std::out_of_range& e) {
56455       {
56456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56457       };
56458     } catch (std::exception& e) {
56459       {
56460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56461       };
56462     } catch (Dali::DaliException e) {
56463       {
56464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56465       };
56466     } catch (...) {
56467       {
56468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56469       };
56470     }
56471   }
56472
56473   jresult = (void *)result;
56474   return jresult;
56475 }
56476
56477
56478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56479   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56480
56481   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56482   {
56483     try {
56484       delete arg1;
56485     } catch (std::out_of_range& e) {
56486       {
56487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56488       };
56489     } catch (std::exception& e) {
56490       {
56491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56492       };
56493     } catch (Dali::DaliException e) {
56494       {
56495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56496       };
56497     } catch (...) {
56498       {
56499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56500       };
56501     }
56502   }
56503
56504 }
56505
56506
56507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56508   unsigned int jresult ;
56509   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56510   bool result;
56511
56512   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56513   {
56514     try {
56515       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56516     } catch (std::out_of_range& e) {
56517       {
56518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56519       };
56520     } catch (std::exception& e) {
56521       {
56522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56523       };
56524     } catch (Dali::DaliException e) {
56525       {
56526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56527       };
56528     } catch (...) {
56529       {
56530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56531       };
56532     }
56533   }
56534
56535   jresult = result;
56536   return jresult;
56537 }
56538
56539
56540 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56541   unsigned long jresult ;
56542   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56543   std::size_t result;
56544
56545   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56546   {
56547     try {
56548       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56549     } catch (std::out_of_range& e) {
56550       {
56551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56552       };
56553     } catch (std::exception& e) {
56554       {
56555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56556       };
56557     } catch (Dali::DaliException e) {
56558       {
56559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56560       };
56561     } catch (...) {
56562       {
56563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56564       };
56565     }
56566   }
56567
56568   jresult = (unsigned long)result;
56569   return jresult;
56570 }
56571
56572
56573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56574   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56575   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56576
56577   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56578   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56579   {
56580     try {
56581       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56582     } catch (std::out_of_range& e) {
56583       {
56584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56585       };
56586     } catch (std::exception& e) {
56587       {
56588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56589       };
56590     } catch (Dali::DaliException e) {
56591       {
56592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56593       };
56594     } catch (...) {
56595       {
56596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56597       };
56598     }
56599   }
56600
56601 }
56602
56603
56604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56605   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56606   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56607
56608   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56609   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56610   {
56611     try {
56612       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56613     } catch (std::out_of_range& e) {
56614       {
56615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56616       };
56617     } catch (std::exception& e) {
56618       {
56619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56620       };
56621     } catch (Dali::DaliException e) {
56622       {
56623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56624       };
56625     } catch (...) {
56626       {
56627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56628       };
56629     }
56630   }
56631
56632 }
56633
56634
56635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56636   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56637   Dali::TouchData *arg2 = 0 ;
56638
56639   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56640   arg2 = (Dali::TouchData *)jarg2;
56641   if (!arg2) {
56642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56643     return ;
56644   }
56645   {
56646     try {
56647       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56648     } catch (std::out_of_range& e) {
56649       {
56650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56651       };
56652     } catch (std::exception& e) {
56653       {
56654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56655       };
56656     } catch (Dali::DaliException e) {
56657       {
56658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56659       };
56660     } catch (...) {
56661       {
56662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56663       };
56664     }
56665   }
56666
56667 }
56668
56669
56670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56671   void * jresult ;
56672   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56673
56674   {
56675     try {
56676       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56677     } catch (std::out_of_range& e) {
56678       {
56679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56680       };
56681     } catch (std::exception& e) {
56682       {
56683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56684       };
56685     } catch (Dali::DaliException e) {
56686       {
56687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56688       };
56689     } catch (...) {
56690       {
56691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56692       };
56693     }
56694   }
56695
56696   jresult = (void *)result;
56697   return jresult;
56698 }
56699
56700
56701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56702   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56703
56704   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56705   {
56706     try {
56707       delete arg1;
56708     } catch (std::out_of_range& e) {
56709       {
56710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56711       };
56712     } catch (std::exception& e) {
56713       {
56714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56715       };
56716     } catch (Dali::DaliException e) {
56717       {
56718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56719       };
56720     } catch (...) {
56721       {
56722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56723       };
56724     }
56725   }
56726
56727 }
56728
56729
56730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56731   unsigned int jresult ;
56732   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56733   bool result;
56734
56735   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56736   {
56737     try {
56738       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56739     } catch (std::out_of_range& e) {
56740       {
56741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56742       };
56743     } catch (std::exception& e) {
56744       {
56745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56746       };
56747     } catch (Dali::DaliException e) {
56748       {
56749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56750       };
56751     } catch (...) {
56752       {
56753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56754       };
56755     }
56756   }
56757
56758   jresult = result;
56759   return jresult;
56760 }
56761
56762
56763 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56764   unsigned long jresult ;
56765   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56766   std::size_t result;
56767
56768   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56769   {
56770     try {
56771       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56772     } catch (std::out_of_range& e) {
56773       {
56774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56775       };
56776     } catch (std::exception& e) {
56777       {
56778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56779       };
56780     } catch (Dali::DaliException e) {
56781       {
56782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56783       };
56784     } catch (...) {
56785       {
56786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56787       };
56788     }
56789   }
56790
56791   jresult = (unsigned long)result;
56792   return jresult;
56793 }
56794
56795
56796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56797   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56798   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56799
56800   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56801   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56802   {
56803     try {
56804       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56805     } catch (std::out_of_range& e) {
56806       {
56807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56808       };
56809     } catch (std::exception& e) {
56810       {
56811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56812       };
56813     } catch (Dali::DaliException e) {
56814       {
56815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56816       };
56817     } catch (...) {
56818       {
56819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56820       };
56821     }
56822   }
56823
56824 }
56825
56826
56827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56828   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56829   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56830
56831   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56832   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56833   {
56834     try {
56835       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56836     } catch (std::out_of_range& e) {
56837       {
56838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56839       };
56840     } catch (std::exception& e) {
56841       {
56842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56843       };
56844     } catch (Dali::DaliException e) {
56845       {
56846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56847       };
56848     } catch (...) {
56849       {
56850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56851       };
56852     }
56853   }
56854
56855 }
56856
56857
56858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56859   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56860   Dali::WheelEvent *arg2 = 0 ;
56861
56862   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56863   arg2 = (Dali::WheelEvent *)jarg2;
56864   if (!arg2) {
56865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56866     return ;
56867   }
56868   {
56869     try {
56870       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56871     } catch (std::out_of_range& e) {
56872       {
56873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56874       };
56875     } catch (std::exception& e) {
56876       {
56877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56878       };
56879     } catch (Dali::DaliException e) {
56880       {
56881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56882       };
56883     } catch (...) {
56884       {
56885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56886       };
56887     }
56888   }
56889
56890 }
56891
56892
56893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56894   void * jresult ;
56895   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56896
56897   {
56898     try {
56899       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56900     } catch (std::out_of_range& e) {
56901       {
56902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56903       };
56904     } catch (std::exception& e) {
56905       {
56906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56907       };
56908     } catch (Dali::DaliException e) {
56909       {
56910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56911       };
56912     } catch (...) {
56913       {
56914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56915       };
56916     }
56917   }
56918
56919   jresult = (void *)result;
56920   return jresult;
56921 }
56922
56923
56924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56925   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56926
56927   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56928   {
56929     try {
56930       delete arg1;
56931     } catch (std::out_of_range& e) {
56932       {
56933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56934       };
56935     } catch (std::exception& e) {
56936       {
56937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56938       };
56939     } catch (Dali::DaliException e) {
56940       {
56941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56942       };
56943     } catch (...) {
56944       {
56945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56946       };
56947     }
56948   }
56949
56950 }
56951
56952
56953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56954   void * jresult ;
56955   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56956
56957   {
56958     try {
56959       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56960     } catch (std::out_of_range& e) {
56961       {
56962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56963       };
56964     } catch (std::exception& e) {
56965       {
56966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56967       };
56968     } catch (Dali::DaliException e) {
56969       {
56970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56971       };
56972     } catch (...) {
56973       {
56974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56975       };
56976     }
56977   }
56978
56979   jresult = (void *)result;
56980   return jresult;
56981 }
56982
56983
56984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56985   void * jresult ;
56986   Dali::Radian arg1 ;
56987   Dali::Radian arg2 ;
56988   Dali::Radian *argp1 ;
56989   Dali::Radian *argp2 ;
56990   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56991
56992   argp1 = (Dali::Radian *)jarg1;
56993   if (!argp1) {
56994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56995     return 0;
56996   }
56997   arg1 = *argp1;
56998   argp2 = (Dali::Radian *)jarg2;
56999   if (!argp2) {
57000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
57001     return 0;
57002   }
57003   arg2 = *argp2;
57004   {
57005     try {
57006       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
57007     } catch (std::out_of_range& e) {
57008       {
57009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57010       };
57011     } catch (std::exception& e) {
57012       {
57013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57014       };
57015     } catch (Dali::DaliException e) {
57016       {
57017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57018       };
57019     } catch (...) {
57020       {
57021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57022       };
57023     }
57024   }
57025
57026   jresult = (void *)result;
57027   return jresult;
57028 }
57029
57030
57031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
57032   void * jresult ;
57033   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
57034   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57035
57036   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57037   if (!arg1) {
57038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
57039     return 0;
57040   }
57041   {
57042     try {
57043       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
57044     } catch (std::out_of_range& e) {
57045       {
57046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57047       };
57048     } catch (std::exception& e) {
57049       {
57050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57051       };
57052     } catch (Dali::DaliException e) {
57053       {
57054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57055       };
57056     } catch (...) {
57057       {
57058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57059       };
57060     }
57061   }
57062
57063   jresult = (void *)result;
57064   return jresult;
57065 }
57066
57067
57068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
57069   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57070   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57071
57072   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57073   arg2 = (Dali::Radian *)jarg2;
57074   if (arg1) (arg1)->first = *arg2;
57075 }
57076
57077
57078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
57079   void * jresult ;
57080   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57081   Dali::Radian *result = 0 ;
57082
57083   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57084   result = (Dali::Radian *)& ((arg1)->first);
57085   jresult = (void *)result;
57086   return jresult;
57087 }
57088
57089
57090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57091   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57092   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57093
57094   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57095   arg2 = (Dali::Radian *)jarg2;
57096   if (arg1) (arg1)->second = *arg2;
57097 }
57098
57099
57100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57101   void * jresult ;
57102   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57103   Dali::Radian *result = 0 ;
57104
57105   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57106   result = (Dali::Radian *)& ((arg1)->second);
57107   jresult = (void *)result;
57108   return jresult;
57109 }
57110
57111
57112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57113   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57114
57115   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57116   {
57117     try {
57118       delete arg1;
57119     } catch (std::out_of_range& e) {
57120       {
57121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57122       };
57123     } catch (std::exception& e) {
57124       {
57125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57126       };
57127     } catch (Dali::DaliException e) {
57128       {
57129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57130       };
57131     } catch (...) {
57132       {
57133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57134       };
57135     }
57136   }
57137
57138 }
57139
57140
57141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57142   unsigned int jresult ;
57143   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57144   bool result;
57145
57146   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57147   {
57148     try {
57149       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *)arg1);
57150     } catch (std::out_of_range& e) {
57151       {
57152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57153       };
57154     } catch (std::exception& e) {
57155       {
57156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57157       };
57158     } catch (Dali::DaliException e) {
57159       {
57160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57161       };
57162     } catch (...) {
57163       {
57164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57165       };
57166     }
57167   }
57168
57169   jresult = result;
57170   return jresult;
57171 }
57172
57173
57174 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57175   unsigned long jresult ;
57176   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57177   std::size_t result;
57178
57179   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57180   {
57181     try {
57182       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *)arg1);
57183     } catch (std::out_of_range& e) {
57184       {
57185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57186       };
57187     } catch (std::exception& e) {
57188       {
57189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57190       };
57191     } catch (Dali::DaliException e) {
57192       {
57193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57194       };
57195     } catch (...) {
57196       {
57197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57198       };
57199     }
57200   }
57201
57202   jresult = (unsigned long)result;
57203   return jresult;
57204 }
57205
57206
57207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57208   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57209   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57210
57211   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57212   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57213   {
57214     try {
57215       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57216     } catch (std::out_of_range& e) {
57217       {
57218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57219       };
57220     } catch (std::exception& e) {
57221       {
57222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57223       };
57224     } catch (Dali::DaliException e) {
57225       {
57226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57227       };
57228     } catch (...) {
57229       {
57230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57231       };
57232     }
57233   }
57234
57235 }
57236
57237
57238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57239   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57240   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57241
57242   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57243   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57244   {
57245     try {
57246       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57247     } catch (std::out_of_range& e) {
57248       {
57249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57250       };
57251     } catch (std::exception& e) {
57252       {
57253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57254       };
57255     } catch (Dali::DaliException e) {
57256       {
57257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57258       };
57259     } catch (...) {
57260       {
57261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57262       };
57263     }
57264   }
57265
57266 }
57267
57268
57269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57270   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57271   Dali::Actor arg2 ;
57272   Dali::PanGesture *arg3 = 0 ;
57273   Dali::Actor *argp2 ;
57274
57275   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57276   argp2 = (Dali::Actor *)jarg2;
57277   if (!argp2) {
57278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57279     return ;
57280   }
57281   arg2 = *argp2;
57282   arg3 = (Dali::PanGesture *)jarg3;
57283   if (!arg3) {
57284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57285     return ;
57286   }
57287   {
57288     try {
57289       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57290     } catch (std::out_of_range& e) {
57291       {
57292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57293       };
57294     } catch (std::exception& e) {
57295       {
57296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57297       };
57298     } catch (Dali::DaliException e) {
57299       {
57300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57301       };
57302     } catch (...) {
57303       {
57304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57305       };
57306     }
57307   }
57308
57309 }
57310
57311
57312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57313   void * jresult ;
57314   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57315
57316   {
57317     try {
57318       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57319     } catch (std::out_of_range& e) {
57320       {
57321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57322       };
57323     } catch (std::exception& e) {
57324       {
57325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57326       };
57327     } catch (Dali::DaliException e) {
57328       {
57329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57330       };
57331     } catch (...) {
57332       {
57333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57334       };
57335     }
57336   }
57337
57338   jresult = (void *)result;
57339   return jresult;
57340 }
57341
57342
57343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57344   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57345
57346   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57347   {
57348     try {
57349       delete arg1;
57350     } catch (std::out_of_range& e) {
57351       {
57352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57353       };
57354     } catch (std::exception& e) {
57355       {
57356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57357       };
57358     } catch (Dali::DaliException e) {
57359       {
57360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57361       };
57362     } catch (...) {
57363       {
57364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57365       };
57366     }
57367   }
57368
57369 }
57370
57371
57372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57373   unsigned int jresult ;
57374   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57375   bool result;
57376
57377   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57378   {
57379     try {
57380       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *)arg1);
57381     } catch (std::out_of_range& e) {
57382       {
57383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57384       };
57385     } catch (std::exception& e) {
57386       {
57387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57388       };
57389     } catch (Dali::DaliException e) {
57390       {
57391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57392       };
57393     } catch (...) {
57394       {
57395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57396       };
57397     }
57398   }
57399
57400   jresult = result;
57401   return jresult;
57402 }
57403
57404
57405 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57406   unsigned long jresult ;
57407   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57408   std::size_t result;
57409
57410   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57411   {
57412     try {
57413       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *)arg1);
57414     } catch (std::out_of_range& e) {
57415       {
57416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57417       };
57418     } catch (std::exception& e) {
57419       {
57420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57421       };
57422     } catch (Dali::DaliException e) {
57423       {
57424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57425       };
57426     } catch (...) {
57427       {
57428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57429       };
57430     }
57431   }
57432
57433   jresult = (unsigned long)result;
57434   return jresult;
57435 }
57436
57437
57438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57439   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57440   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57441
57442   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57443   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57444   {
57445     try {
57446       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57447     } catch (std::out_of_range& e) {
57448       {
57449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57450       };
57451     } catch (std::exception& e) {
57452       {
57453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57454       };
57455     } catch (Dali::DaliException e) {
57456       {
57457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57458       };
57459     } catch (...) {
57460       {
57461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57462       };
57463     }
57464   }
57465
57466 }
57467
57468
57469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57470   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57471   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57472
57473   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57474   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57475   {
57476     try {
57477       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57478     } catch (std::out_of_range& e) {
57479       {
57480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57481       };
57482     } catch (std::exception& e) {
57483       {
57484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57485       };
57486     } catch (Dali::DaliException e) {
57487       {
57488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57489       };
57490     } catch (...) {
57491       {
57492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57493       };
57494     }
57495   }
57496
57497 }
57498
57499
57500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57501   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57502   Dali::Actor arg2 ;
57503   Dali::PinchGesture *arg3 = 0 ;
57504   Dali::Actor *argp2 ;
57505
57506   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57507   argp2 = (Dali::Actor *)jarg2;
57508   if (!argp2) {
57509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57510     return ;
57511   }
57512   arg2 = *argp2;
57513   arg3 = (Dali::PinchGesture *)jarg3;
57514   if (!arg3) {
57515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57516     return ;
57517   }
57518   {
57519     try {
57520       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57521     } catch (std::out_of_range& e) {
57522       {
57523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57524       };
57525     } catch (std::exception& e) {
57526       {
57527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57528       };
57529     } catch (Dali::DaliException e) {
57530       {
57531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57532       };
57533     } catch (...) {
57534       {
57535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57536       };
57537     }
57538   }
57539
57540 }
57541
57542
57543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57544   void * jresult ;
57545   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57546
57547   {
57548     try {
57549       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57550     } catch (std::out_of_range& e) {
57551       {
57552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57553       };
57554     } catch (std::exception& e) {
57555       {
57556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57557       };
57558     } catch (Dali::DaliException e) {
57559       {
57560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57561       };
57562     } catch (...) {
57563       {
57564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57565       };
57566     }
57567   }
57568
57569   jresult = (void *)result;
57570   return jresult;
57571 }
57572
57573
57574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57575   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57576
57577   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57578   {
57579     try {
57580       delete arg1;
57581     } catch (std::out_of_range& e) {
57582       {
57583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57584       };
57585     } catch (std::exception& e) {
57586       {
57587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57588       };
57589     } catch (Dali::DaliException e) {
57590       {
57591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57592       };
57593     } catch (...) {
57594       {
57595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57596       };
57597     }
57598   }
57599
57600 }
57601
57602
57603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57604   unsigned int jresult ;
57605   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57606   bool result;
57607
57608   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57609   {
57610     try {
57611       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *)arg1);
57612     } catch (std::out_of_range& e) {
57613       {
57614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57615       };
57616     } catch (std::exception& e) {
57617       {
57618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57619       };
57620     } catch (Dali::DaliException e) {
57621       {
57622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57623       };
57624     } catch (...) {
57625       {
57626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57627       };
57628     }
57629   }
57630
57631   jresult = result;
57632   return jresult;
57633 }
57634
57635
57636 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57637   unsigned long jresult ;
57638   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57639   std::size_t result;
57640
57641   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57642   {
57643     try {
57644       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *)arg1);
57645     } catch (std::out_of_range& e) {
57646       {
57647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57648       };
57649     } catch (std::exception& e) {
57650       {
57651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57652       };
57653     } catch (Dali::DaliException e) {
57654       {
57655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57656       };
57657     } catch (...) {
57658       {
57659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57660       };
57661     }
57662   }
57663
57664   jresult = (unsigned long)result;
57665   return jresult;
57666 }
57667
57668
57669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57670   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57671   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57672
57673   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57674   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57675   {
57676     try {
57677       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57678     } catch (std::out_of_range& e) {
57679       {
57680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57681       };
57682     } catch (std::exception& e) {
57683       {
57684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57685       };
57686     } catch (Dali::DaliException e) {
57687       {
57688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57689       };
57690     } catch (...) {
57691       {
57692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57693       };
57694     }
57695   }
57696
57697 }
57698
57699
57700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57701   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57702   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57703
57704   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57705   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57706   {
57707     try {
57708       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57709     } catch (std::out_of_range& e) {
57710       {
57711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57712       };
57713     } catch (std::exception& e) {
57714       {
57715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57716       };
57717     } catch (Dali::DaliException e) {
57718       {
57719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57720       };
57721     } catch (...) {
57722       {
57723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57724       };
57725     }
57726   }
57727
57728 }
57729
57730
57731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57732   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57733   Dali::Actor arg2 ;
57734   Dali::TapGesture *arg3 = 0 ;
57735   Dali::Actor *argp2 ;
57736
57737   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57738   argp2 = (Dali::Actor *)jarg2;
57739   if (!argp2) {
57740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57741     return ;
57742   }
57743   arg2 = *argp2;
57744   arg3 = (Dali::TapGesture *)jarg3;
57745   if (!arg3) {
57746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57747     return ;
57748   }
57749   {
57750     try {
57751       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57752     } catch (std::out_of_range& e) {
57753       {
57754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57755       };
57756     } catch (std::exception& e) {
57757       {
57758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57759       };
57760     } catch (Dali::DaliException e) {
57761       {
57762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57763       };
57764     } catch (...) {
57765       {
57766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57767       };
57768     }
57769   }
57770
57771 }
57772
57773
57774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57775   void * jresult ;
57776   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57777
57778   {
57779     try {
57780       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57781     } catch (std::out_of_range& e) {
57782       {
57783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57784       };
57785     } catch (std::exception& e) {
57786       {
57787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57788       };
57789     } catch (Dali::DaliException e) {
57790       {
57791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57792       };
57793     } catch (...) {
57794       {
57795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57796       };
57797     }
57798   }
57799
57800   jresult = (void *)result;
57801   return jresult;
57802 }
57803
57804
57805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57806   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57807
57808   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57809   {
57810     try {
57811       delete arg1;
57812     } catch (std::out_of_range& e) {
57813       {
57814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57815       };
57816     } catch (std::exception& e) {
57817       {
57818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57819       };
57820     } catch (Dali::DaliException e) {
57821       {
57822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57823       };
57824     } catch (...) {
57825       {
57826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57827       };
57828     }
57829   }
57830
57831 }
57832
57833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57834   unsigned int jresult ;
57835   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57836   bool result;
57837
57838   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57839   {
57840     try {
57841       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57842     } catch (std::out_of_range& e) {
57843       {
57844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57845       };
57846     } catch (std::exception& e) {
57847       {
57848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57849       };
57850     } catch (Dali::DaliException e) {
57851       {
57852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57853       };
57854     } catch (...) {
57855       {
57856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57857       };
57858     }
57859   }
57860
57861   jresult = result;
57862   return jresult;
57863 }
57864
57865
57866 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57867   unsigned long jresult ;
57868   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57869   std::size_t result;
57870
57871   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57872   {
57873     try {
57874       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57875     } catch (std::out_of_range& e) {
57876       {
57877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57878       };
57879     } catch (std::exception& e) {
57880       {
57881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57882       };
57883     } catch (Dali::DaliException e) {
57884       {
57885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57886       };
57887     } catch (...) {
57888       {
57889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57890       };
57891     }
57892   }
57893
57894   jresult = (unsigned long)result;
57895   return jresult;
57896 }
57897
57898
57899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57900   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57901   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57902
57903   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57904   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57905   {
57906     try {
57907       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57908     } catch (std::out_of_range& e) {
57909       {
57910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57911       };
57912     } catch (std::exception& e) {
57913       {
57914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57915       };
57916     } catch (Dali::DaliException e) {
57917       {
57918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57919       };
57920     } catch (...) {
57921       {
57922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57923       };
57924     }
57925   }
57926
57927 }
57928
57929
57930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57931   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57932   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57933
57934   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57935   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57936   {
57937     try {
57938       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57939     } catch (std::out_of_range& e) {
57940       {
57941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57942       };
57943     } catch (std::exception& e) {
57944       {
57945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57946       };
57947     } catch (Dali::DaliException e) {
57948       {
57949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57950       };
57951     } catch (...) {
57952       {
57953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57954       };
57955     }
57956   }
57957
57958 }
57959
57960
57961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57962   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57963   Dali::ResourceImage arg2 ;
57964   Dali::ResourceImage *argp2 ;
57965
57966   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57967   argp2 = (Dali::ResourceImage *)jarg2;
57968   if (!argp2) {
57969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57970     return ;
57971   }
57972   arg2 = *argp2;
57973   {
57974     try {
57975       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57976     } catch (std::out_of_range& e) {
57977       {
57978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57979       };
57980     } catch (std::exception& e) {
57981       {
57982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57983       };
57984     } catch (Dali::DaliException e) {
57985       {
57986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57987       };
57988     } catch (...) {
57989       {
57990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57991       };
57992     }
57993   }
57994
57995 }
57996
57997
57998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57999   void * jresult ;
58000   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
58001
58002   {
58003     try {
58004       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
58005     } catch (std::out_of_range& e) {
58006       {
58007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58008       };
58009     } catch (std::exception& e) {
58010       {
58011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58012       };
58013     } catch (Dali::DaliException e) {
58014       {
58015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58016       };
58017     } catch (...) {
58018       {
58019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58020       };
58021     }
58022   }
58023
58024   jresult = (void *)result;
58025   return jresult;
58026 }
58027
58028
58029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
58030   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
58031
58032   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58033   {
58034     try {
58035       delete arg1;
58036     } catch (std::out_of_range& e) {
58037       {
58038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58039       };
58040     } catch (std::exception& e) {
58041       {
58042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58043       };
58044     } catch (Dali::DaliException e) {
58045       {
58046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58047       };
58048     } catch (...) {
58049       {
58050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58051       };
58052     }
58053   }
58054
58055 }
58056
58057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
58058   unsigned int jresult ;
58059   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58060   bool result = false;
58061
58062   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58063   {
58064     try {
58065       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *)arg1);
58066     } catch (std::out_of_range& e) {
58067       {
58068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58069       };
58070     } catch (std::exception& e) {
58071       {
58072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58073       };
58074     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58075   }
58076   jresult = result;
58077   return jresult;
58078 }
58079
58080 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
58081   unsigned long jresult ;
58082   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58083   std::size_t result = 0;
58084
58085   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58086   {
58087     try {
58088       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *)arg1);
58089     } catch (std::out_of_range& e) {
58090       {
58091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58092       };
58093     } catch (std::exception& e) {
58094       {
58095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58096       };
58097     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58098   }
58099   jresult = (unsigned long)result;
58100   return jresult;
58101 }
58102
58103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58104   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58105   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58106
58107   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58108   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58109   {
58110     try {
58111       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58112     } catch (std::out_of_range& e) {
58113       {
58114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58115       };
58116     } catch (std::exception& e) {
58117       {
58118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58119       };
58120     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58121   }
58122 }
58123
58124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58125   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58126   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58127
58128   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58129   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58130   {
58131     try {
58132       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58133     } catch (std::out_of_range& e) {
58134       {
58135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58136       };
58137     } catch (std::exception& e) {
58138       {
58139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58140       };
58141     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58142   }
58143 }
58144
58145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58146   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58147   Dali::Actor arg2 ;
58148   //bool arg3 ;
58149   Dali::LayoutDirection::Type arg4 ;
58150   Dali::Actor *argp2 ;
58151
58152   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58153   argp2 = (Dali::Actor *)jarg2;
58154   if (!argp2) {
58155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58156     return ;
58157   }
58158   arg2 = *argp2;
58159   //arg3 = jarg3 ? true : false;
58160   arg4 = (Dali::LayoutDirection::Type)jarg4;
58161   {
58162     try {
58163       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58164     } catch (std::out_of_range& e) {
58165       {
58166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58167       };
58168     } catch (std::exception& e) {
58169       {
58170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58171       };
58172     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58173   }
58174 }
58175
58176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58177   void * jresult ;
58178   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58179
58180   {
58181     try {
58182       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58183     } catch (std::out_of_range& e) {
58184       {
58185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58186       };
58187     } catch (std::exception& e) {
58188       {
58189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58190       };
58191     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58192   }
58193   jresult = (void *)result;
58194   return jresult;
58195 }
58196
58197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58198   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58199
58200   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58201   {
58202     try {
58203       delete arg1;
58204     } catch (std::out_of_range& e) {
58205       {
58206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58207       };
58208     } catch (std::exception& e) {
58209       {
58210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58211       };
58212     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58213   }
58214 }
58215
58216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58217   unsigned int jresult ;
58218   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58219   bool result;
58220
58221   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58222   {
58223     try {
58224       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
58225     } catch (std::out_of_range& e) {
58226       {
58227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58228       };
58229     } catch (std::exception& e) {
58230       {
58231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58232       };
58233     } catch (Dali::DaliException e) {
58234       {
58235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58236       };
58237     } catch (...) {
58238       {
58239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58240       };
58241     }
58242   }
58243
58244   jresult = result;
58245   return jresult;
58246 }
58247
58248
58249 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58250   unsigned long jresult ;
58251   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58252   std::size_t result;
58253
58254   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58255   {
58256     try {
58257       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
58258     } catch (std::out_of_range& e) {
58259       {
58260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58261       };
58262     } catch (std::exception& e) {
58263       {
58264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58265       };
58266     } catch (Dali::DaliException e) {
58267       {
58268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58269       };
58270     } catch (...) {
58271       {
58272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58273       };
58274     }
58275   }
58276
58277   jresult = (unsigned long)result;
58278   return jresult;
58279 }
58280
58281
58282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58283   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58284   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58285
58286   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58287   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58288   {
58289     try {
58290       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58291     } catch (std::out_of_range& e) {
58292       {
58293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58294       };
58295     } catch (std::exception& e) {
58296       {
58297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58298       };
58299     } catch (Dali::DaliException e) {
58300       {
58301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58302       };
58303     } catch (...) {
58304       {
58305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58306       };
58307     }
58308   }
58309
58310 }
58311
58312
58313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58314   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58315   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58316
58317   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58318   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58319   {
58320     try {
58321       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58322     } catch (std::out_of_range& e) {
58323       {
58324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58325       };
58326     } catch (std::exception& e) {
58327       {
58328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58329       };
58330     } catch (Dali::DaliException e) {
58331       {
58332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58333       };
58334     } catch (...) {
58335       {
58336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58337       };
58338     }
58339   }
58340
58341 }
58342
58343
58344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58345   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58346   Dali::Actor arg2 ;
58347   bool arg3 ;
58348   Dali::DevelActor::VisibilityChange::Type arg4 ;
58349   Dali::Actor *argp2 ;
58350
58351   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58352   argp2 = (Dali::Actor *)jarg2;
58353   if (!argp2) {
58354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58355     return ;
58356   }
58357   arg2 = *argp2;
58358   arg3 = jarg3 ? true : false;
58359   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58360   {
58361     try {
58362       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58363     } catch (std::out_of_range& e) {
58364       {
58365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58366       };
58367     } catch (std::exception& e) {
58368       {
58369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58370       };
58371     } catch (Dali::DaliException e) {
58372       {
58373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58374       };
58375     } catch (...) {
58376       {
58377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58378       };
58379     }
58380   }
58381
58382 }
58383
58384
58385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58386   void * jresult ;
58387   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58388
58389   {
58390     try {
58391       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58392     } catch (std::out_of_range& e) {
58393       {
58394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58395       };
58396     } catch (std::exception& e) {
58397       {
58398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58399       };
58400     } catch (Dali::DaliException e) {
58401       {
58402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58403       };
58404     } catch (...) {
58405       {
58406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58407       };
58408     }
58409   }
58410
58411   jresult = (void *)result;
58412   return jresult;
58413 }
58414
58415
58416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58417   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58418
58419   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58420   {
58421     try {
58422       delete arg1;
58423     } catch (std::out_of_range& e) {
58424       {
58425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58426       };
58427     } catch (std::exception& e) {
58428       {
58429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58430       };
58431     } catch (Dali::DaliException e) {
58432       {
58433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58434       };
58435     } catch (...) {
58436       {
58437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58438       };
58439     }
58440   }
58441
58442 }
58443
58444
58445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58446   void * jresult ;
58447   Dali::Timer *result = 0 ;
58448
58449   {
58450     try {
58451       result = (Dali::Timer *)new Dali::Timer();
58452     } catch (std::out_of_range& e) {
58453       {
58454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58455       };
58456     } catch (std::exception& e) {
58457       {
58458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58459       };
58460     } catch (Dali::DaliException e) {
58461       {
58462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58463       };
58464     } catch (...) {
58465       {
58466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58467       };
58468     }
58469   }
58470
58471   jresult = (void *)result;
58472   return jresult;
58473 }
58474
58475
58476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58477   void * jresult ;
58478   unsigned int arg1 ;
58479   Dali::Timer result;
58480
58481   arg1 = (unsigned int)jarg1;
58482   {
58483     try {
58484       result = Dali::Timer::New(arg1);
58485     } catch (std::out_of_range& e) {
58486       {
58487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58488       };
58489     } catch (std::exception& e) {
58490       {
58491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58492       };
58493     } catch (Dali::DaliException e) {
58494       {
58495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58496       };
58497     } catch (...) {
58498       {
58499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58500       };
58501     }
58502   }
58503
58504   jresult = new Dali::Timer((const Dali::Timer &)result);
58505   return jresult;
58506 }
58507
58508
58509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58510   void * jresult ;
58511   Dali::Timer *arg1 = 0 ;
58512   Dali::Timer *result = 0 ;
58513
58514   arg1 = (Dali::Timer *)jarg1;
58515   if (!arg1) {
58516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58517     return 0;
58518   }
58519   {
58520     try {
58521       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58522     } catch (std::out_of_range& e) {
58523       {
58524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58525       };
58526     } catch (std::exception& e) {
58527       {
58528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58529       };
58530     } catch (Dali::DaliException e) {
58531       {
58532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58533       };
58534     } catch (...) {
58535       {
58536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58537       };
58538     }
58539   }
58540
58541   jresult = (void *)result;
58542   return jresult;
58543 }
58544
58545
58546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58547   void * jresult ;
58548   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58549   Dali::Timer *arg2 = 0 ;
58550   Dali::Timer *result = 0 ;
58551
58552   arg1 = (Dali::Timer *)jarg1;
58553   arg2 = (Dali::Timer *)jarg2;
58554   if (!arg2) {
58555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58556     return 0;
58557   }
58558   {
58559     try {
58560       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58561     } catch (std::out_of_range& e) {
58562       {
58563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58564       };
58565     } catch (std::exception& e) {
58566       {
58567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58568       };
58569     } catch (Dali::DaliException e) {
58570       {
58571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58572       };
58573     } catch (...) {
58574       {
58575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58576       };
58577     }
58578   }
58579
58580   jresult = (void *)result;
58581   return jresult;
58582 }
58583
58584
58585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58586   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58587
58588   arg1 = (Dali::Timer *)jarg1;
58589   {
58590     try {
58591       delete arg1;
58592     } catch (std::out_of_range& e) {
58593       {
58594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58595       };
58596     } catch (std::exception& e) {
58597       {
58598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58599       };
58600     } catch (Dali::DaliException e) {
58601       {
58602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58603       };
58604     } catch (...) {
58605       {
58606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58607       };
58608     }
58609   }
58610
58611 }
58612
58613
58614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58615   void * jresult ;
58616   Dali::BaseHandle arg1 ;
58617   Dali::BaseHandle *argp1 ;
58618   Dali::Timer result;
58619
58620   argp1 = (Dali::BaseHandle *)jarg1;
58621   if (!argp1) {
58622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58623     return 0;
58624   }
58625   arg1 = *argp1;
58626   {
58627     try {
58628       result = Dali::Timer::DownCast(arg1);
58629     } catch (std::out_of_range& e) {
58630       {
58631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58632       };
58633     } catch (std::exception& e) {
58634       {
58635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58636       };
58637     } catch (Dali::DaliException e) {
58638       {
58639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58640       };
58641     } catch (...) {
58642       {
58643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58644       };
58645     }
58646   }
58647
58648   jresult = new Dali::Timer((const Dali::Timer &)result);
58649   return jresult;
58650 }
58651
58652
58653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58654   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58655
58656   arg1 = (Dali::Timer *)jarg1;
58657   {
58658     try {
58659       (arg1)->Start();
58660     } catch (std::out_of_range& e) {
58661       {
58662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58663       };
58664     } catch (std::exception& e) {
58665       {
58666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58667       };
58668     } catch (Dali::DaliException e) {
58669       {
58670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58671       };
58672     } catch (...) {
58673       {
58674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58675       };
58676     }
58677   }
58678
58679 }
58680
58681
58682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58683   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58684
58685   arg1 = (Dali::Timer *)jarg1;
58686   {
58687     try {
58688       (arg1)->Stop();
58689     } catch (std::out_of_range& e) {
58690       {
58691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58692       };
58693     } catch (std::exception& e) {
58694       {
58695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58696       };
58697     } catch (Dali::DaliException e) {
58698       {
58699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58700       };
58701     } catch (...) {
58702       {
58703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58704       };
58705     }
58706   }
58707
58708 }
58709
58710
58711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58712   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58713   unsigned int arg2 ;
58714
58715   arg1 = (Dali::Timer *)jarg1;
58716   arg2 = (unsigned int)jarg2;
58717   {
58718     try {
58719       (arg1)->SetInterval(arg2);
58720     } catch (std::out_of_range& e) {
58721       {
58722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58723       };
58724     } catch (std::exception& e) {
58725       {
58726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58727       };
58728     } catch (Dali::DaliException e) {
58729       {
58730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58731       };
58732     } catch (...) {
58733       {
58734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58735       };
58736     }
58737   }
58738
58739 }
58740
58741
58742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58743   unsigned int jresult ;
58744   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58745   unsigned int result;
58746
58747   arg1 = (Dali::Timer *)jarg1;
58748   {
58749     try {
58750       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58751     } catch (std::out_of_range& e) {
58752       {
58753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58754       };
58755     } catch (std::exception& e) {
58756       {
58757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58758       };
58759     } catch (Dali::DaliException e) {
58760       {
58761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58762       };
58763     } catch (...) {
58764       {
58765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58766       };
58767     }
58768   }
58769
58770   jresult = result;
58771   return jresult;
58772 }
58773
58774
58775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58776   unsigned int jresult ;
58777   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58778   bool result;
58779
58780   arg1 = (Dali::Timer *)jarg1;
58781   {
58782     try {
58783       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58784     } catch (std::out_of_range& e) {
58785       {
58786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58787       };
58788     } catch (std::exception& e) {
58789       {
58790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58791       };
58792     } catch (Dali::DaliException e) {
58793       {
58794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58795       };
58796     } catch (...) {
58797       {
58798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58799       };
58800     }
58801   }
58802
58803   jresult = result;
58804   return jresult;
58805 }
58806
58807
58808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58809   void * jresult ;
58810   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58811   Dali::Timer::TimerSignalType *result = 0 ;
58812
58813   arg1 = (Dali::Timer *)jarg1;
58814   {
58815     try {
58816       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58817     } catch (std::out_of_range& e) {
58818       {
58819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58820       };
58821     } catch (std::exception& e) {
58822       {
58823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58824       };
58825     } catch (Dali::DaliException e) {
58826       {
58827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58828       };
58829     } catch (...) {
58830       {
58831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58832       };
58833     }
58834   }
58835
58836   jresult = (void *)result;
58837   return jresult;
58838 }
58839
58840
58841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
58842   unsigned int jresult ;
58843   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58844   bool result;
58845
58846   arg1 = (Dali::Signal< bool () > *)jarg1;
58847   {
58848     try {
58849       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
58850     } catch (std::out_of_range& e) {
58851       {
58852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58853       };
58854     } catch (std::exception& e) {
58855       {
58856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58857       };
58858     } catch (Dali::DaliException e) {
58859       {
58860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58861       };
58862     } catch (...) {
58863       {
58864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58865       };
58866     }
58867   }
58868
58869   jresult = result;
58870   return jresult;
58871 }
58872
58873
58874 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
58875   unsigned long jresult ;
58876   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58877   std::size_t result;
58878
58879   arg1 = (Dali::Signal< bool () > *)jarg1;
58880   {
58881     try {
58882       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
58883     } catch (std::out_of_range& e) {
58884       {
58885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58886       };
58887     } catch (std::exception& e) {
58888       {
58889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58890       };
58891     } catch (Dali::DaliException e) {
58892       {
58893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58894       };
58895     } catch (...) {
58896       {
58897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58898       };
58899     }
58900   }
58901
58902   jresult = (unsigned long)result;
58903   return jresult;
58904 }
58905
58906
58907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
58908   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58909   bool (*arg2)() = (bool (*)()) 0 ;
58910
58911   arg1 = (Dali::Signal< bool () > *)jarg1;
58912   arg2 = (bool (*)())jarg2;
58913   {
58914     try {
58915       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
58916     } catch (std::out_of_range& e) {
58917       {
58918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58919       };
58920     } catch (std::exception& e) {
58921       {
58922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58923       };
58924     } catch (Dali::DaliException e) {
58925       {
58926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58927       };
58928     } catch (...) {
58929       {
58930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58931       };
58932     }
58933   }
58934
58935 }
58936
58937
58938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
58939   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58940   bool (*arg2)() = (bool (*)()) 0 ;
58941
58942   arg1 = (Dali::Signal< bool () > *)jarg1;
58943   arg2 = (bool (*)())jarg2;
58944   {
58945     try {
58946       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
58947     } catch (std::out_of_range& e) {
58948       {
58949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58950       };
58951     } catch (std::exception& e) {
58952       {
58953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58954       };
58955     } catch (Dali::DaliException e) {
58956       {
58957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58958       };
58959     } catch (...) {
58960       {
58961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58962       };
58963     }
58964   }
58965
58966 }
58967
58968
58969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
58970   unsigned int jresult ;
58971   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58972   bool result;
58973
58974   arg1 = (Dali::Signal< bool () > *)jarg1;
58975   {
58976     try {
58977       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
58978     } catch (std::out_of_range& e) {
58979       {
58980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58981       };
58982     } catch (std::exception& e) {
58983       {
58984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58985       };
58986     } catch (Dali::DaliException e) {
58987       {
58988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58989       };
58990     } catch (...) {
58991       {
58992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58993       };
58994     }
58995   }
58996
58997   jresult = result;
58998   return jresult;
58999 }
59000
59001
59002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59003   void * jresult ;
59004   Dali::Signal< bool () > *result = 0 ;
59005
59006   {
59007     try {
59008       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59009     } catch (std::out_of_range& e) {
59010       {
59011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59012       };
59013     } catch (std::exception& e) {
59014       {
59015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59016       };
59017     } catch (Dali::DaliException e) {
59018       {
59019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59020       };
59021     } catch (...) {
59022       {
59023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59024       };
59025     }
59026   }
59027
59028   jresult = (void *)result;
59029   return jresult;
59030 }
59031
59032
59033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59034   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59035
59036   arg1 = (Dali::Signal< bool () > *)jarg1;
59037   {
59038     try {
59039       delete arg1;
59040     } catch (std::out_of_range& e) {
59041       {
59042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59043       };
59044     } catch (std::exception& e) {
59045       {
59046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59047       };
59048     } catch (Dali::DaliException e) {
59049       {
59050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59051       };
59052     } catch (...) {
59053       {
59054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59055       };
59056     }
59057   }
59058
59059 }
59060
59061
59062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59063   int jresult ;
59064   int result;
59065
59066   {
59067     try {
59068       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59069     } catch (std::out_of_range& e) {
59070       {
59071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59072       };
59073     } catch (std::exception& e) {
59074       {
59075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59076       };
59077     } catch (Dali::DaliException e) {
59078       {
59079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59080       };
59081     } catch (...) {
59082       {
59083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59084       };
59085     }
59086   }
59087
59088   jresult = (int)result;
59089   return jresult;
59090 }
59091
59092
59093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59094   int jresult ;
59095   int result;
59096
59097   {
59098     try {
59099       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59100     } catch (std::out_of_range& e) {
59101       {
59102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59103       };
59104     } catch (std::exception& e) {
59105       {
59106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59107       };
59108     } catch (Dali::DaliException e) {
59109       {
59110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59111       };
59112     } catch (...) {
59113       {
59114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59115       };
59116     }
59117   }
59118
59119   jresult = (int)result;
59120   return jresult;
59121 }
59122
59123
59124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59125   int jresult ;
59126   int result;
59127
59128   {
59129     try {
59130       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59131     } catch (std::out_of_range& e) {
59132       {
59133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59134       };
59135     } catch (std::exception& e) {
59136       {
59137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59138       };
59139     } catch (Dali::DaliException e) {
59140       {
59141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59142       };
59143     } catch (...) {
59144       {
59145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59146       };
59147     }
59148   }
59149
59150   jresult = (int)result;
59151   return jresult;
59152 }
59153
59154
59155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59156   int jresult ;
59157   int result;
59158
59159   {
59160     try {
59161       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59162     } catch (std::out_of_range& e) {
59163       {
59164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59165       };
59166     } catch (std::exception& e) {
59167       {
59168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59169       };
59170     } catch (Dali::DaliException e) {
59171       {
59172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59173       };
59174     } catch (...) {
59175       {
59176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59177       };
59178     }
59179   }
59180
59181   jresult = (int)result;
59182   return jresult;
59183 }
59184
59185
59186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59187   int jresult ;
59188   int result;
59189
59190   {
59191     try {
59192       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59193     } catch (std::out_of_range& e) {
59194       {
59195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59196       };
59197     } catch (std::exception& e) {
59198       {
59199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59200       };
59201     } catch (Dali::DaliException e) {
59202       {
59203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59204       };
59205     } catch (...) {
59206       {
59207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59208       };
59209     }
59210   }
59211
59212   jresult = (int)result;
59213   return jresult;
59214 }
59215
59216
59217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59218   int jresult ;
59219   int result;
59220
59221   {
59222     try {
59223       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59224     } catch (std::out_of_range& e) {
59225       {
59226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59227       };
59228     } catch (std::exception& e) {
59229       {
59230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59231       };
59232     } catch (Dali::DaliException e) {
59233       {
59234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59235       };
59236     } catch (...) {
59237       {
59238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59239       };
59240     }
59241   }
59242
59243   jresult = (int)result;
59244   return jresult;
59245 }
59246
59247
59248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59249   int jresult ;
59250   int result;
59251
59252   {
59253     try {
59254       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59255     } catch (std::out_of_range& e) {
59256       {
59257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59258       };
59259     } catch (std::exception& e) {
59260       {
59261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59262       };
59263     } catch (Dali::DaliException e) {
59264       {
59265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59266       };
59267     } catch (...) {
59268       {
59269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59270       };
59271     }
59272   }
59273
59274   jresult = (int)result;
59275   return jresult;
59276 }
59277
59278
59279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59280   int jresult ;
59281   int result;
59282
59283   {
59284     try {
59285       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59286     } catch (std::out_of_range& e) {
59287       {
59288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59289       };
59290     } catch (std::exception& e) {
59291       {
59292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59293       };
59294     } catch (Dali::DaliException e) {
59295       {
59296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59297       };
59298     } catch (...) {
59299       {
59300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59301       };
59302     }
59303   }
59304
59305   jresult = (int)result;
59306   return jresult;
59307 }
59308
59309
59310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59311   int jresult ;
59312   int result;
59313
59314   {
59315     try {
59316       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59317     } catch (std::out_of_range& e) {
59318       {
59319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59320       };
59321     } catch (std::exception& e) {
59322       {
59323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59324       };
59325     } catch (Dali::DaliException e) {
59326       {
59327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59328       };
59329     } catch (...) {
59330       {
59331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59332       };
59333     }
59334   }
59335
59336   jresult = (int)result;
59337   return jresult;
59338 }
59339
59340
59341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59342   int jresult ;
59343   int result;
59344
59345   {
59346     try {
59347       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59348     } catch (std::out_of_range& e) {
59349       {
59350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59351       };
59352     } catch (std::exception& e) {
59353       {
59354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59355       };
59356     } catch (Dali::DaliException e) {
59357       {
59358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59359       };
59360     } catch (...) {
59361       {
59362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59363       };
59364     }
59365   }
59366
59367   jresult = (int)result;
59368   return jresult;
59369 }
59370
59371
59372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59373   int jresult ;
59374   int result;
59375
59376   {
59377     try {
59378       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59379     } catch (std::out_of_range& e) {
59380       {
59381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59382       };
59383     } catch (std::exception& e) {
59384       {
59385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59386       };
59387     } catch (Dali::DaliException e) {
59388       {
59389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59390       };
59391     } catch (...) {
59392       {
59393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59394       };
59395     }
59396   }
59397
59398   jresult = (int)result;
59399   return jresult;
59400 }
59401
59402
59403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59404   int jresult ;
59405   int result;
59406
59407   {
59408     try {
59409       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59410     } catch (std::out_of_range& e) {
59411       {
59412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59413       };
59414     } catch (std::exception& e) {
59415       {
59416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59417       };
59418     } catch (Dali::DaliException e) {
59419       {
59420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59421       };
59422     } catch (...) {
59423       {
59424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59425       };
59426     }
59427   }
59428
59429   jresult = (int)result;
59430   return jresult;
59431 }
59432
59433
59434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59435   int jresult ;
59436   int result;
59437
59438   {
59439     try {
59440       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59441     } catch (std::out_of_range& e) {
59442       {
59443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59444       };
59445     } catch (std::exception& e) {
59446       {
59447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59448       };
59449     } catch (Dali::DaliException e) {
59450       {
59451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59452       };
59453     } catch (...) {
59454       {
59455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59456       };
59457     }
59458   }
59459
59460   jresult = (int)result;
59461   return jresult;
59462 }
59463
59464
59465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59466   int jresult ;
59467   int result;
59468
59469   {
59470     try {
59471       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59472     } catch (std::out_of_range& e) {
59473       {
59474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59475       };
59476     } catch (std::exception& e) {
59477       {
59478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59479       };
59480     } catch (Dali::DaliException e) {
59481       {
59482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59483       };
59484     } catch (...) {
59485       {
59486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59487       };
59488     }
59489   }
59490
59491   jresult = (int)result;
59492   return jresult;
59493 }
59494
59495
59496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59497   int jresult ;
59498   int result;
59499
59500   {
59501     try {
59502       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59503     } catch (std::out_of_range& e) {
59504       {
59505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59506       };
59507     } catch (std::exception& e) {
59508       {
59509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59510       };
59511     } catch (Dali::DaliException e) {
59512       {
59513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59514       };
59515     } catch (...) {
59516       {
59517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59518       };
59519     }
59520   }
59521
59522   jresult = (int)result;
59523   return jresult;
59524 }
59525
59526
59527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59528   int jresult ;
59529   int result;
59530
59531   {
59532     try {
59533       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59534     } catch (std::out_of_range& e) {
59535       {
59536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59537       };
59538     } catch (std::exception& e) {
59539       {
59540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59541       };
59542     } catch (Dali::DaliException e) {
59543       {
59544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59545       };
59546     } catch (...) {
59547       {
59548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59549       };
59550     }
59551   }
59552
59553   jresult = (int)result;
59554   return jresult;
59555 }
59556
59557
59558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59559   int jresult ;
59560   int result;
59561
59562   {
59563     try {
59564       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59565     } catch (std::out_of_range& e) {
59566       {
59567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59568       };
59569     } catch (std::exception& e) {
59570       {
59571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59572       };
59573     } catch (Dali::DaliException e) {
59574       {
59575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59576       };
59577     } catch (...) {
59578       {
59579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59580       };
59581     }
59582   }
59583
59584   jresult = (int)result;
59585   return jresult;
59586 }
59587
59588
59589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59590   int jresult ;
59591   int result;
59592
59593   {
59594     try {
59595       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59596     } catch (std::out_of_range& e) {
59597       {
59598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59599       };
59600     } catch (std::exception& e) {
59601       {
59602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59603       };
59604     } catch (Dali::DaliException e) {
59605       {
59606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59607       };
59608     } catch (...) {
59609       {
59610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59611       };
59612     }
59613   }
59614
59615   jresult = (int)result;
59616   return jresult;
59617 }
59618
59619
59620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59621   int jresult ;
59622   int result;
59623
59624   {
59625     try {
59626       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59627     } catch (std::out_of_range& e) {
59628       {
59629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59630       };
59631     } catch (std::exception& e) {
59632       {
59633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59634       };
59635     } catch (Dali::DaliException e) {
59636       {
59637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59638       };
59639     } catch (...) {
59640       {
59641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59642       };
59643     }
59644   }
59645
59646   jresult = (int)result;
59647   return jresult;
59648 }
59649
59650
59651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59652   int jresult ;
59653   int result;
59654
59655   {
59656     try {
59657       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59658     } catch (std::out_of_range& e) {
59659       {
59660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59661       };
59662     } catch (std::exception& e) {
59663       {
59664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59665       };
59666     } catch (Dali::DaliException e) {
59667       {
59668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59669       };
59670     } catch (...) {
59671       {
59672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59673       };
59674     }
59675   }
59676
59677   jresult = (int)result;
59678   return jresult;
59679 }
59680
59681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59682   int jresult ;
59683   int result;
59684
59685   {
59686     try {
59687       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59688     } catch (std::out_of_range& e) {
59689       {
59690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59691       };
59692     } catch (std::exception& e) {
59693       {
59694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59695       };
59696     } catch (Dali::DaliException e) {
59697       {
59698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59699       };
59700     } catch (...) {
59701       {
59702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59703       };
59704     }
59705   }
59706
59707   jresult = (int)result;
59708   return jresult;
59709 }
59710
59711
59712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59713   int jresult ;
59714   int result;
59715   {
59716     try
59717     {
59718       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59719     } catch (std::out_of_range& e) {
59720       {
59721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59722       };
59723     } catch (std::exception& e) {
59724       {
59725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59726       };
59727     } catch (Dali::DaliException e) {
59728       {
59729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59730       };
59731     } catch (...) {
59732       {
59733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59734       };
59735     }
59736   }
59737
59738   jresult = (int)result;
59739   return jresult;
59740 }
59741
59742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59743   int jresult ;
59744   int result;
59745   {
59746     try
59747     {
59748       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59749     } catch (std::out_of_range& e) {
59750       {
59751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59752       };
59753     } catch (std::exception& e) {
59754       {
59755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59756       };
59757     } catch (Dali::DaliException e) {
59758       {
59759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59760       };
59761     } catch (...) {
59762       {
59763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59764       };
59765     }
59766   }
59767
59768   jresult = (int)result;
59769   return jresult;
59770 }
59771
59772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59773   int jresult ;
59774   int result;
59775   {
59776     try
59777     {
59778       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59779     } catch (std::out_of_range& e) {
59780       {
59781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59782       };
59783     } catch (std::exception& e) {
59784       {
59785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59786       };
59787     } catch (Dali::DaliException e) {
59788       {
59789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59790       };
59791     } catch (...) {
59792       {
59793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59794       };
59795     }
59796   }
59797
59798   jresult = (int)result;
59799   return jresult;
59800 }
59801
59802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59803   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59804 }
59805
59806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59807   int jresult ;
59808   int result;
59809   {
59810     try
59811     {
59812       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59813     } catch (std::out_of_range& e) {
59814       {
59815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59816       };
59817     } catch (std::exception& e) {
59818       {
59819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59820       };
59821     } catch (Dali::DaliException e) {
59822       {
59823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59824       };
59825     } catch (...) {
59826       {
59827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59828       };
59829     }
59830   }
59831
59832   jresult = (int)result;
59833   return jresult;
59834 }
59835
59836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
59837   int jresult ;
59838   int result;
59839   {
59840     try
59841     {
59842       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
59843     } catch (std::out_of_range& e) {
59844       {
59845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59846       };
59847     } catch (std::exception& e) {
59848       {
59849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59850       };
59851     } catch (Dali::DaliException e) {
59852       {
59853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59854       };
59855     } catch (...) {
59856       {
59857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59858       };
59859     }
59860   }
59861
59862   jresult = (int)result;
59863   return jresult;
59864 }
59865
59866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
59867   int jresult ;
59868   int result;
59869
59870   {
59871     try {
59872       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
59873     } catch (std::out_of_range& e) {
59874       {
59875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59876       };
59877     } catch (std::exception& e) {
59878       {
59879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59880       };
59881     } catch (Dali::DaliException e) {
59882       {
59883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59884       };
59885     } catch (...) {
59886       {
59887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59888       };
59889     }
59890   }
59891
59892   jresult = (int)result;
59893   return jresult;
59894 }
59895
59896
59897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
59898   int jresult ;
59899   int result;
59900
59901   {
59902     try {
59903       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
59904     } catch (std::out_of_range& e) {
59905       {
59906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59907       };
59908     } catch (std::exception& e) {
59909       {
59910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59911       };
59912     } catch (Dali::DaliException e) {
59913       {
59914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59915       };
59916     } catch (...) {
59917       {
59918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59919       };
59920     }
59921   }
59922
59923   jresult = (int)result;
59924   return jresult;
59925 }
59926
59927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
59928   int jresult ;
59929   int result;
59930   {
59931     try
59932     {
59933       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
59934     } catch (std::out_of_range& e) {
59935       {
59936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59937       };
59938     } catch (std::exception& e) {
59939       {
59940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59941       };
59942     } catch (...) {
59943       {
59944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59945       };
59946     }
59947   }
59948   jresult = (int)result;
59949   return jresult;
59950 }
59951
59952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
59953   int jresult ;
59954   int result;
59955   {
59956     try
59957     {
59958       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
59959     } catch (std::out_of_range& e) {
59960       {
59961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59962       };
59963     } catch (std::exception& e) {
59964       {
59965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59966       };
59967     } catch (...) {
59968       {
59969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59970       };
59971     }
59972   }
59973   jresult = (int)result;
59974   return jresult;
59975 }
59976
59977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
59978   int jresult ;
59979   int result;
59980   {
59981     try
59982     {
59983       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
59984     } catch (std::out_of_range& e) {
59985       {
59986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59987       };
59988     } catch (std::exception& e) {
59989       {
59990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59991       };
59992     } catch (...) {
59993       {
59994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59995       };
59996     }
59997   }
59998   jresult = (int)result;
59999   return jresult;
60000 }
60001
60002
60003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60004   int jresult ;
60005   int result;
60006   {
60007     try
60008     {
60009       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60010     } catch (std::out_of_range& e) {
60011       {
60012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60013       };
60014     } catch (std::exception& e) {
60015       {
60016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60017       };
60018     } catch (...) {
60019       {
60020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60021       };
60022     }
60023   }
60024   jresult = (int)result;
60025   return jresult;
60026 }
60027
60028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60029   int jresult ;
60030   int result;
60031   {
60032     try
60033     {
60034       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60035     } catch (std::out_of_range& e) {
60036       {
60037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60038       };
60039     } catch (std::exception& e) {
60040       {
60041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60042       };
60043     } catch (...) {
60044       {
60045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60046       };
60047     }
60048   }
60049   jresult = (int)result;
60050   return jresult;
60051 }
60052
60053
60054
60055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60056   int jresult ;
60057   int result;
60058
60059   {
60060     try {
60061       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60062     } catch (std::out_of_range& e) {
60063       {
60064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60065       };
60066     } catch (std::exception& e) {
60067       {
60068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60069       };
60070     } catch (Dali::DaliException e) {
60071       {
60072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60073       };
60074     } catch (...) {
60075       {
60076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60077       };
60078     }
60079   }
60080
60081   jresult = (int)result;
60082   return jresult;
60083 }
60084
60085
60086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60087   int jresult ;
60088   int result;
60089
60090   {
60091     try {
60092       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60093     } catch (std::out_of_range& e) {
60094       {
60095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60096       };
60097     } catch (std::exception& e) {
60098       {
60099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60100       };
60101     } catch (Dali::DaliException e) {
60102       {
60103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60104       };
60105     } catch (...) {
60106       {
60107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60108       };
60109     }
60110   }
60111
60112   jresult = (int)result;
60113   return jresult;
60114 }
60115
60116
60117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60118   int jresult ;
60119   int result;
60120
60121   {
60122     try {
60123       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60124     } catch (std::out_of_range& e) {
60125       {
60126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60127       };
60128     } catch (std::exception& e) {
60129       {
60130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60131       };
60132     } catch (Dali::DaliException e) {
60133       {
60134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60135       };
60136     } catch (...) {
60137       {
60138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60139       };
60140     }
60141   }
60142
60143   jresult = (int)result;
60144   return jresult;
60145 }
60146
60147
60148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60149   int jresult ;
60150   int result;
60151
60152   {
60153     try {
60154       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60155     } catch (std::out_of_range& e) {
60156       {
60157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60158       };
60159     } catch (std::exception& e) {
60160       {
60161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60162       };
60163     } catch (Dali::DaliException e) {
60164       {
60165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60166       };
60167     } catch (...) {
60168       {
60169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60170       };
60171     }
60172   }
60173
60174   jresult = (int)result;
60175   return jresult;
60176 }
60177
60178
60179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60180   int jresult ;
60181   int result;
60182
60183   {
60184     try {
60185       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60186     } catch (std::out_of_range& e) {
60187       {
60188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60189       };
60190     } catch (std::exception& e) {
60191       {
60192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60193       };
60194     } catch (Dali::DaliException e) {
60195       {
60196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60197       };
60198     } catch (...) {
60199       {
60200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60201       };
60202     }
60203   }
60204
60205   jresult = (int)result;
60206   return jresult;
60207 }
60208
60209
60210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60211   int jresult ;
60212   int result;
60213
60214   {
60215     try {
60216       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60217     } catch (std::out_of_range& e) {
60218       {
60219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60220       };
60221     } catch (std::exception& e) {
60222       {
60223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60224       };
60225     } catch (Dali::DaliException e) {
60226       {
60227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60228       };
60229     } catch (...) {
60230       {
60231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60232       };
60233     }
60234   }
60235
60236   jresult = (int)result;
60237   return jresult;
60238 }
60239
60240
60241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60242   int jresult ;
60243   int result;
60244
60245   {
60246     try {
60247       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60248     } catch (std::out_of_range& e) {
60249       {
60250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60251       };
60252     } catch (std::exception& e) {
60253       {
60254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60255       };
60256     } catch (Dali::DaliException e) {
60257       {
60258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60259       };
60260     } catch (...) {
60261       {
60262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60263       };
60264     }
60265   }
60266
60267   jresult = (int)result;
60268   return jresult;
60269 }
60270
60271 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60272   int jresult ;
60273   int result;
60274
60275   {
60276     try {
60277       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60278     } catch (std::out_of_range& e) {
60279       {
60280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60281       };
60282     } catch (std::exception& e) {
60283       {
60284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60285       };
60286     } catch (...) {
60287       {
60288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60289       };
60290     }
60291   }
60292   jresult = (int)result;
60293   return jresult;
60294 }
60295
60296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60297   int jresult ;
60298   int result;
60299
60300   {
60301     try {
60302       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60303     } catch (std::out_of_range& e) {
60304       {
60305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60306       };
60307     } catch (std::exception& e) {
60308       {
60309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60310       };
60311     } catch (Dali::DaliException e) {
60312       {
60313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60314       };
60315     } catch (...) {
60316       {
60317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60318       };
60319     }
60320   }
60321
60322   jresult = (int)result;
60323   return jresult;
60324 }
60325
60326
60327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60328   int jresult ;
60329   int result;
60330
60331   {
60332     try {
60333       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60334     } catch (std::out_of_range& e) {
60335       {
60336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60337       };
60338     } catch (std::exception& e) {
60339       {
60340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60341       };
60342     } catch (Dali::DaliException e) {
60343       {
60344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60345       };
60346     } catch (...) {
60347       {
60348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60349       };
60350     }
60351   }
60352
60353   jresult = (int)result;
60354   return jresult;
60355 }
60356
60357
60358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60359   int jresult ;
60360   int result;
60361
60362   {
60363     try {
60364       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60365     } catch (std::out_of_range& e) {
60366       {
60367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60368       };
60369     } catch (std::exception& e) {
60370       {
60371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60372       };
60373     } catch (Dali::DaliException e) {
60374       {
60375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60376       };
60377     } catch (...) {
60378       {
60379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60380       };
60381     }
60382   }
60383
60384   jresult = (int)result;
60385   return jresult;
60386 }
60387
60388
60389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60390   int jresult ;
60391   int result;
60392
60393   {
60394     try {
60395       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60396     } catch (std::out_of_range& e) {
60397       {
60398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60399       };
60400     } catch (std::exception& e) {
60401       {
60402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60403       };
60404     } catch (Dali::DaliException e) {
60405       {
60406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60407       };
60408     } catch (...) {
60409       {
60410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60411       };
60412     }
60413   }
60414
60415   jresult = (int)result;
60416   return jresult;
60417 }
60418
60419
60420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60421   int jresult ;
60422   int result;
60423
60424   {
60425     try {
60426       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60427     } catch (std::out_of_range& e) {
60428       {
60429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60430       };
60431     } catch (std::exception& e) {
60432       {
60433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60434       };
60435     } catch (Dali::DaliException e) {
60436       {
60437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60438       };
60439     } catch (...) {
60440       {
60441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60442       };
60443     }
60444   }
60445
60446   jresult = (int)result;
60447   return jresult;
60448 }
60449
60450
60451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60452   int jresult ;
60453   int result;
60454
60455   {
60456     try {
60457       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60458     } catch (std::out_of_range& e) {
60459       {
60460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60461       };
60462     } catch (std::exception& e) {
60463       {
60464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60465       };
60466     } catch (Dali::DaliException e) {
60467       {
60468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60469       };
60470     } catch (...) {
60471       {
60472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60473       };
60474     }
60475   }
60476
60477   jresult = (int)result;
60478   return jresult;
60479 }
60480
60481
60482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60483   int jresult ;
60484   int result;
60485
60486   {
60487     try {
60488       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60489     } catch (std::out_of_range& e) {
60490       {
60491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60492       };
60493     } catch (std::exception& e) {
60494       {
60495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60496       };
60497     } catch (Dali::DaliException e) {
60498       {
60499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60500       };
60501     } catch (...) {
60502       {
60503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60504       };
60505     }
60506   }
60507
60508   jresult = (int)result;
60509   return jresult;
60510 }
60511
60512
60513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60514   int jresult ;
60515   int result;
60516
60517   {
60518     try {
60519       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60520     } catch (std::out_of_range& e) {
60521       {
60522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60523       };
60524     } catch (std::exception& e) {
60525       {
60526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60527       };
60528     } catch (Dali::DaliException e) {
60529       {
60530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60531       };
60532     } catch (...) {
60533       {
60534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60535       };
60536     }
60537   }
60538
60539   jresult = (int)result;
60540   return jresult;
60541 }
60542
60543
60544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60545   int jresult ;
60546   int result;
60547
60548   {
60549     try {
60550       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60551     } catch (std::out_of_range& e) {
60552       {
60553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60554       };
60555     } catch (std::exception& e) {
60556       {
60557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60558       };
60559     } catch (Dali::DaliException e) {
60560       {
60561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60562       };
60563     } catch (...) {
60564       {
60565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60566       };
60567     }
60568   }
60569
60570   jresult = (int)result;
60571   return jresult;
60572 }
60573
60574
60575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60576   int jresult ;
60577   int result;
60578
60579   {
60580     try {
60581       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60582     } catch (std::out_of_range& e) {
60583       {
60584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60585       };
60586     } catch (std::exception& e) {
60587       {
60588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60589       };
60590     } catch (Dali::DaliException e) {
60591       {
60592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60593       };
60594     } catch (...) {
60595       {
60596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60597       };
60598     }
60599   }
60600
60601   jresult = (int)result;
60602   return jresult;
60603 }
60604
60605
60606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60607   int jresult ;
60608   int result;
60609
60610   {
60611     try {
60612       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60613     } catch (std::out_of_range& e) {
60614       {
60615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60616       };
60617     } catch (std::exception& e) {
60618       {
60619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60620       };
60621     } catch (Dali::DaliException e) {
60622       {
60623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60624       };
60625     } catch (...) {
60626       {
60627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60628       };
60629     }
60630   }
60631
60632   jresult = (int)result;
60633   return jresult;
60634 }
60635
60636
60637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60638   int jresult ;
60639   int result;
60640
60641   {
60642     try {
60643       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60644     } catch (std::out_of_range& e) {
60645       {
60646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60647       };
60648     } catch (std::exception& e) {
60649       {
60650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60651       };
60652     } catch (Dali::DaliException e) {
60653       {
60654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60655       };
60656     } catch (...) {
60657       {
60658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60659       };
60660     }
60661   }
60662
60663   jresult = (int)result;
60664   return jresult;
60665 }
60666
60667
60668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60669   int jresult ;
60670   int result;
60671
60672   {
60673     try {
60674       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60675     } catch (std::out_of_range& e) {
60676       {
60677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60678       };
60679     } catch (std::exception& e) {
60680       {
60681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60682       };
60683     } catch (Dali::DaliException e) {
60684       {
60685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60686       };
60687     } catch (...) {
60688       {
60689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60690       };
60691     }
60692   }
60693
60694   jresult = (int)result;
60695   return jresult;
60696 }
60697
60698
60699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60700   int jresult ;
60701   int result;
60702
60703   {
60704     try {
60705       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60706     } catch (std::out_of_range& e) {
60707       {
60708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60709       };
60710     } catch (std::exception& e) {
60711       {
60712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60713       };
60714     } catch (Dali::DaliException e) {
60715       {
60716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60717       };
60718     } catch (...) {
60719       {
60720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60721       };
60722     }
60723   }
60724
60725   jresult = (int)result;
60726   return jresult;
60727 }
60728
60729
60730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60731   int jresult ;
60732   int result;
60733
60734   {
60735     try {
60736       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60737     } catch (std::out_of_range& e) {
60738       {
60739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60740       };
60741     } catch (std::exception& e) {
60742       {
60743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60744       };
60745     } catch (Dali::DaliException e) {
60746       {
60747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60748       };
60749     } catch (...) {
60750       {
60751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60752       };
60753     }
60754   }
60755
60756   jresult = (int)result;
60757   return jresult;
60758 }
60759
60760
60761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60762   int jresult ;
60763   int result;
60764
60765   {
60766     try {
60767       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60768     } catch (std::out_of_range& e) {
60769       {
60770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60771       };
60772     } catch (std::exception& e) {
60773       {
60774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60775       };
60776     } catch (Dali::DaliException e) {
60777       {
60778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60779       };
60780     } catch (...) {
60781       {
60782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60783       };
60784     }
60785   }
60786
60787   jresult = (int)result;
60788   return jresult;
60789 }
60790
60791
60792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60793   int jresult ;
60794   int result;
60795
60796   {
60797     try {
60798       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60799     } catch (std::out_of_range& e) {
60800       {
60801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60802       };
60803     } catch (std::exception& e) {
60804       {
60805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60806       };
60807     } catch (Dali::DaliException e) {
60808       {
60809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60810       };
60811     } catch (...) {
60812       {
60813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60814       };
60815     }
60816   }
60817
60818   jresult = (int)result;
60819   return jresult;
60820 }
60821
60822
60823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60824   int jresult ;
60825   int result;
60826
60827   {
60828     try {
60829       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60830     } catch (std::out_of_range& e) {
60831       {
60832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60833       };
60834     } catch (std::exception& e) {
60835       {
60836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60837       };
60838     } catch (Dali::DaliException e) {
60839       {
60840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60841       };
60842     } catch (...) {
60843       {
60844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60845       };
60846     }
60847   }
60848
60849   jresult = (int)result;
60850   return jresult;
60851 }
60852
60853
60854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
60855   int jresult ;
60856   int result;
60857
60858   {
60859     try {
60860       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
60861     } catch (std::out_of_range& e) {
60862       {
60863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60864       };
60865     } catch (std::exception& e) {
60866       {
60867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60868       };
60869     } catch (Dali::DaliException e) {
60870       {
60871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60872       };
60873     } catch (...) {
60874       {
60875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60876       };
60877     }
60878   }
60879
60880   jresult = (int)result;
60881   return jresult;
60882 }
60883
60884
60885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
60886   int jresult ;
60887   int result;
60888
60889   {
60890     try {
60891       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
60892     } catch (std::out_of_range& e) {
60893       {
60894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60895       };
60896     } catch (std::exception& e) {
60897       {
60898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60899       };
60900     } catch (Dali::DaliException e) {
60901       {
60902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60903       };
60904     } catch (...) {
60905       {
60906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60907       };
60908     }
60909   }
60910
60911   jresult = (int)result;
60912   return jresult;
60913 }
60914
60915
60916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
60917   int jresult ;
60918   int result;
60919
60920   {
60921     try {
60922       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
60923     } catch (std::out_of_range& e) {
60924       {
60925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60926       };
60927     } catch (std::exception& e) {
60928       {
60929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60930       };
60931     } catch (Dali::DaliException e) {
60932       {
60933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60934       };
60935     } catch (...) {
60936       {
60937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60938       };
60939     }
60940   }
60941
60942   jresult = (int)result;
60943   return jresult;
60944 }
60945
60946
60947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
60948   int jresult ;
60949   int result;
60950
60951   {
60952     try {
60953       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
60954     } catch (std::out_of_range& e) {
60955       {
60956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60957       };
60958     } catch (std::exception& e) {
60959       {
60960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60961       };
60962     } catch (Dali::DaliException e) {
60963       {
60964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60965       };
60966     } catch (...) {
60967       {
60968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60969       };
60970     }
60971   }
60972
60973   jresult = (int)result;
60974   return jresult;
60975 }
60976
60977
60978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
60979   int jresult ;
60980   int result;
60981
60982   {
60983     try {
60984       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
60985     } catch (std::out_of_range& e) {
60986       {
60987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60988       };
60989     } catch (std::exception& e) {
60990       {
60991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60992       };
60993     } catch (Dali::DaliException e) {
60994       {
60995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60996       };
60997     } catch (...) {
60998       {
60999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61000       };
61001     }
61002   }
61003
61004   jresult = (int)result;
61005   return jresult;
61006 }
61007
61008
61009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61010   int jresult ;
61011   int result;
61012
61013   {
61014     try {
61015       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61016     } catch (std::out_of_range& e) {
61017       {
61018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61019       };
61020     } catch (std::exception& e) {
61021       {
61022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61023       };
61024     } catch (Dali::DaliException e) {
61025       {
61026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61027       };
61028     } catch (...) {
61029       {
61030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61031       };
61032     }
61033   }
61034
61035   jresult = (int)result;
61036   return jresult;
61037 }
61038
61039
61040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61041   int jresult ;
61042   int result;
61043
61044   {
61045     try {
61046       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61047     } catch (std::out_of_range& e) {
61048       {
61049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61050       };
61051     } catch (std::exception& e) {
61052       {
61053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61054       };
61055     } catch (Dali::DaliException e) {
61056       {
61057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61058       };
61059     } catch (...) {
61060       {
61061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61062       };
61063     }
61064   }
61065
61066   jresult = (int)result;
61067   return jresult;
61068 }
61069
61070
61071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61072   int jresult ;
61073   int result;
61074
61075   {
61076     try {
61077       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61078     } catch (std::out_of_range& e) {
61079       {
61080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61081       };
61082     } catch (std::exception& e) {
61083       {
61084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61085       };
61086     } catch (Dali::DaliException e) {
61087       {
61088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61089       };
61090     } catch (...) {
61091       {
61092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61093       };
61094     }
61095   }
61096
61097   jresult = (int)result;
61098   return jresult;
61099 }
61100
61101
61102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61103   int jresult ;
61104   int result;
61105
61106   {
61107     try {
61108       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61109     } catch (std::out_of_range& e) {
61110       {
61111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61112       };
61113     } catch (std::exception& e) {
61114       {
61115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61116       };
61117     } catch (Dali::DaliException e) {
61118       {
61119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61120       };
61121     } catch (...) {
61122       {
61123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61124       };
61125     }
61126   }
61127
61128   jresult = (int)result;
61129   return jresult;
61130 }
61131
61132
61133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61134   int jresult ;
61135   int result;
61136
61137   {
61138     try {
61139       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61140     } catch (std::out_of_range& e) {
61141       {
61142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61143       };
61144     } catch (std::exception& e) {
61145       {
61146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61147       };
61148     } catch (Dali::DaliException e) {
61149       {
61150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61151       };
61152     } catch (...) {
61153       {
61154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61155       };
61156     }
61157   }
61158
61159   jresult = (int)result;
61160   return jresult;
61161 }
61162
61163
61164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61165   void * jresult ;
61166   Dali::Toolkit::Builder *result = 0 ;
61167
61168   {
61169     try {
61170       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61171     } catch (std::out_of_range& e) {
61172       {
61173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61174       };
61175     } catch (std::exception& e) {
61176       {
61177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61178       };
61179     } catch (Dali::DaliException e) {
61180       {
61181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61182       };
61183     } catch (...) {
61184       {
61185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61186       };
61187     }
61188   }
61189
61190   jresult = (void *)result;
61191   return jresult;
61192 }
61193
61194
61195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61196   void * jresult ;
61197   Dali::Toolkit::Builder result;
61198
61199   {
61200     try {
61201       result = Dali::Toolkit::Builder::New();
61202     } catch (std::out_of_range& e) {
61203       {
61204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61205       };
61206     } catch (std::exception& e) {
61207       {
61208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61209       };
61210     } catch (Dali::DaliException e) {
61211       {
61212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61213       };
61214     } catch (...) {
61215       {
61216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61217       };
61218     }
61219   }
61220
61221   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61222   return jresult;
61223 }
61224
61225
61226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61227   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61228
61229   arg1 = (Dali::Toolkit::Builder *)jarg1;
61230   {
61231     try {
61232       delete arg1;
61233     } catch (std::out_of_range& e) {
61234       {
61235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61236       };
61237     } catch (std::exception& e) {
61238       {
61239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61240       };
61241     } catch (Dali::DaliException e) {
61242       {
61243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61244       };
61245     } catch (...) {
61246       {
61247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61248       };
61249     }
61250   }
61251
61252 }
61253
61254
61255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61256   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61257   std::string *arg2 = 0 ;
61258   Dali::Toolkit::Builder::UIFormat arg3 ;
61259
61260   arg1 = (Dali::Toolkit::Builder *)jarg1;
61261   if (!jarg2) {
61262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61263     return ;
61264   }
61265   std::string arg2_str(jarg2);
61266   arg2 = &arg2_str;
61267   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61268   {
61269     try {
61270       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61271     } catch (std::out_of_range& e) {
61272       {
61273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61274       };
61275     } catch (std::exception& e) {
61276       {
61277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61278       };
61279     } catch (Dali::DaliException e) {
61280       {
61281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61282       };
61283     } catch (...) {
61284       {
61285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61286       };
61287     }
61288   }
61289
61290
61291   //argout typemap for const std::string&
61292
61293 }
61294
61295
61296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61297   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61298   std::string *arg2 = 0 ;
61299
61300   arg1 = (Dali::Toolkit::Builder *)jarg1;
61301   if (!jarg2) {
61302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61303     return ;
61304   }
61305   std::string arg2_str(jarg2);
61306   arg2 = &arg2_str;
61307   {
61308     try {
61309       (arg1)->LoadFromString((std::string const &)*arg2);
61310     } catch (std::out_of_range& e) {
61311       {
61312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61313       };
61314     } catch (std::exception& e) {
61315       {
61316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61317       };
61318     } catch (Dali::DaliException e) {
61319       {
61320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61321       };
61322     } catch (...) {
61323       {
61324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61325       };
61326     }
61327   }
61328
61329
61330   //argout typemap for const std::string&
61331
61332 }
61333
61334
61335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61336   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61337   Dali::Property::Map *arg2 = 0 ;
61338
61339   arg1 = (Dali::Toolkit::Builder *)jarg1;
61340   arg2 = (Dali::Property::Map *)jarg2;
61341   if (!arg2) {
61342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61343     return ;
61344   }
61345   {
61346     try {
61347       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61348     } catch (std::out_of_range& e) {
61349       {
61350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61351       };
61352     } catch (std::exception& e) {
61353       {
61354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61355       };
61356     } catch (Dali::DaliException e) {
61357       {
61358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61359       };
61360     } catch (...) {
61361       {
61362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61363       };
61364     }
61365   }
61366
61367 }
61368
61369
61370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61371   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61372   std::string *arg2 = 0 ;
61373   Dali::Property::Value *arg3 = 0 ;
61374
61375   arg1 = (Dali::Toolkit::Builder *)jarg1;
61376   if (!jarg2) {
61377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61378     return ;
61379   }
61380   std::string arg2_str(jarg2);
61381   arg2 = &arg2_str;
61382   arg3 = (Dali::Property::Value *)jarg3;
61383   if (!arg3) {
61384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61385     return ;
61386   }
61387   {
61388     try {
61389       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61390     } catch (std::out_of_range& e) {
61391       {
61392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61393       };
61394     } catch (std::exception& e) {
61395       {
61396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61397       };
61398     } catch (Dali::DaliException e) {
61399       {
61400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61401       };
61402     } catch (...) {
61403       {
61404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61405       };
61406     }
61407   }
61408
61409
61410   //argout typemap for const std::string&
61411
61412 }
61413
61414
61415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61416   void * jresult ;
61417   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61418   Dali::Property::Map *result = 0 ;
61419
61420   arg1 = (Dali::Toolkit::Builder *)jarg1;
61421   {
61422     try {
61423       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61424     } catch (std::out_of_range& e) {
61425       {
61426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61427       };
61428     } catch (std::exception& e) {
61429       {
61430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61431       };
61432     } catch (Dali::DaliException e) {
61433       {
61434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61435       };
61436     } catch (...) {
61437       {
61438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61439       };
61440     }
61441   }
61442
61443   jresult = (void *)result;
61444   return jresult;
61445 }
61446
61447
61448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61449   void * jresult ;
61450   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61451   std::string *arg2 = 0 ;
61452   Dali::Property::Value *result = 0 ;
61453
61454   arg1 = (Dali::Toolkit::Builder *)jarg1;
61455   if (!jarg2) {
61456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61457     return 0;
61458   }
61459   std::string arg2_str(jarg2);
61460   arg2 = &arg2_str;
61461   {
61462     try {
61463       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61464     } catch (std::out_of_range& e) {
61465       {
61466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61467       };
61468     } catch (std::exception& e) {
61469       {
61470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61471       };
61472     } catch (Dali::DaliException e) {
61473       {
61474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61475       };
61476     } catch (...) {
61477       {
61478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61479       };
61480     }
61481   }
61482
61483   jresult = (void *)result;
61484
61485   //argout typemap for const std::string&
61486
61487   return jresult;
61488 }
61489
61490
61491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61492   void * jresult ;
61493   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61494   std::string *arg2 = 0 ;
61495   Dali::Animation result;
61496
61497   arg1 = (Dali::Toolkit::Builder *)jarg1;
61498   if (!jarg2) {
61499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61500     return 0;
61501   }
61502   std::string arg2_str(jarg2);
61503   arg2 = &arg2_str;
61504   {
61505     try {
61506       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61507     } catch (std::out_of_range& e) {
61508       {
61509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61510       };
61511     } catch (std::exception& e) {
61512       {
61513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61514       };
61515     } catch (Dali::DaliException e) {
61516       {
61517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61518       };
61519     } catch (...) {
61520       {
61521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61522       };
61523     }
61524   }
61525
61526   jresult = new Dali::Animation((const Dali::Animation &)result);
61527
61528   //argout typemap for const std::string&
61529
61530   return jresult;
61531 }
61532
61533
61534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61535   void * jresult ;
61536   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61537   std::string *arg2 = 0 ;
61538   Dali::Property::Map *arg3 = 0 ;
61539   Dali::Animation result;
61540
61541   arg1 = (Dali::Toolkit::Builder *)jarg1;
61542   if (!jarg2) {
61543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61544     return 0;
61545   }
61546   std::string arg2_str(jarg2);
61547   arg2 = &arg2_str;
61548   arg3 = (Dali::Property::Map *)jarg3;
61549   if (!arg3) {
61550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61551     return 0;
61552   }
61553   {
61554     try {
61555       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61556     } catch (std::out_of_range& e) {
61557       {
61558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61559       };
61560     } catch (std::exception& e) {
61561       {
61562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61563       };
61564     } catch (Dali::DaliException e) {
61565       {
61566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61567       };
61568     } catch (...) {
61569       {
61570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61571       };
61572     }
61573   }
61574
61575   jresult = new Dali::Animation((const Dali::Animation &)result);
61576
61577   //argout typemap for const std::string&
61578
61579   return jresult;
61580 }
61581
61582
61583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61584   void * jresult ;
61585   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61586   std::string *arg2 = 0 ;
61587   Dali::Actor arg3 ;
61588   Dali::Actor *argp3 ;
61589   Dali::Animation result;
61590
61591   arg1 = (Dali::Toolkit::Builder *)jarg1;
61592   if (!jarg2) {
61593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61594     return 0;
61595   }
61596   std::string arg2_str(jarg2);
61597   arg2 = &arg2_str;
61598   argp3 = (Dali::Actor *)jarg3;
61599   if (!argp3) {
61600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61601     return 0;
61602   }
61603   arg3 = *argp3;
61604   {
61605     try {
61606       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61607     } catch (std::out_of_range& e) {
61608       {
61609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61610       };
61611     } catch (std::exception& e) {
61612       {
61613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61614       };
61615     } catch (Dali::DaliException e) {
61616       {
61617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61618       };
61619     } catch (...) {
61620       {
61621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61622       };
61623     }
61624   }
61625
61626   jresult = new Dali::Animation((const Dali::Animation &)result);
61627
61628   //argout typemap for const std::string&
61629
61630   return jresult;
61631 }
61632
61633
61634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61635   void * jresult ;
61636   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61637   std::string *arg2 = 0 ;
61638   Dali::Property::Map *arg3 = 0 ;
61639   Dali::Actor arg4 ;
61640   Dali::Actor *argp4 ;
61641   Dali::Animation result;
61642
61643   arg1 = (Dali::Toolkit::Builder *)jarg1;
61644   if (!jarg2) {
61645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61646     return 0;
61647   }
61648   std::string arg2_str(jarg2);
61649   arg2 = &arg2_str;
61650   arg3 = (Dali::Property::Map *)jarg3;
61651   if (!arg3) {
61652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61653     return 0;
61654   }
61655   argp4 = (Dali::Actor *)jarg4;
61656   if (!argp4) {
61657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61658     return 0;
61659   }
61660   arg4 = *argp4;
61661   {
61662     try {
61663       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61664     } catch (std::out_of_range& e) {
61665       {
61666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61667       };
61668     } catch (std::exception& e) {
61669       {
61670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61671       };
61672     } catch (Dali::DaliException e) {
61673       {
61674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61675       };
61676     } catch (...) {
61677       {
61678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61679       };
61680     }
61681   }
61682
61683   jresult = new Dali::Animation((const Dali::Animation &)result);
61684
61685   //argout typemap for const std::string&
61686
61687   return jresult;
61688 }
61689
61690
61691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61692   void * jresult ;
61693   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61694   std::string *arg2 = 0 ;
61695   Dali::BaseHandle result;
61696
61697   arg1 = (Dali::Toolkit::Builder *)jarg1;
61698   if (!jarg2) {
61699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61700     return 0;
61701   }
61702   std::string arg2_str(jarg2);
61703   arg2 = &arg2_str;
61704   {
61705     try {
61706       result = (arg1)->Create((std::string const &)*arg2);
61707     } catch (std::out_of_range& e) {
61708       {
61709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61710       };
61711     } catch (std::exception& e) {
61712       {
61713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61714       };
61715     } catch (Dali::DaliException e) {
61716       {
61717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61718       };
61719     } catch (...) {
61720       {
61721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61722       };
61723     }
61724   }
61725
61726   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61727
61728   //argout typemap for const std::string&
61729
61730   return jresult;
61731 }
61732
61733
61734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61735   void * jresult ;
61736   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61737   std::string *arg2 = 0 ;
61738   Dali::Property::Map *arg3 = 0 ;
61739   Dali::BaseHandle result;
61740
61741   arg1 = (Dali::Toolkit::Builder *)jarg1;
61742   if (!jarg2) {
61743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61744     return 0;
61745   }
61746   std::string arg2_str(jarg2);
61747   arg2 = &arg2_str;
61748   arg3 = (Dali::Property::Map *)jarg3;
61749   if (!arg3) {
61750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61751     return 0;
61752   }
61753   {
61754     try {
61755       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61756     } catch (std::out_of_range& e) {
61757       {
61758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61759       };
61760     } catch (std::exception& e) {
61761       {
61762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61763       };
61764     } catch (Dali::DaliException e) {
61765       {
61766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61767       };
61768     } catch (...) {
61769       {
61770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61771       };
61772     }
61773   }
61774
61775   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61776
61777   //argout typemap for const std::string&
61778
61779   return jresult;
61780 }
61781
61782
61783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61784   void * jresult ;
61785   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61786   std::string *arg2 = 0 ;
61787   Dali::BaseHandle result;
61788
61789   arg1 = (Dali::Toolkit::Builder *)jarg1;
61790   if (!jarg2) {
61791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61792     return 0;
61793   }
61794   std::string arg2_str(jarg2);
61795   arg2 = &arg2_str;
61796   {
61797     try {
61798       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61799     } catch (std::out_of_range& e) {
61800       {
61801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61802       };
61803     } catch (std::exception& e) {
61804       {
61805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61806       };
61807     } catch (Dali::DaliException e) {
61808       {
61809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61810       };
61811     } catch (...) {
61812       {
61813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61814       };
61815     }
61816   }
61817
61818   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61819
61820   //argout typemap for const std::string&
61821
61822   return jresult;
61823 }
61824
61825
61826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61827   unsigned int jresult ;
61828   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61829   std::string *arg2 = 0 ;
61830   Dali::Handle *arg3 = 0 ;
61831   bool result;
61832
61833   arg1 = (Dali::Toolkit::Builder *)jarg1;
61834   if (!jarg2) {
61835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61836     return 0;
61837   }
61838   std::string arg2_str(jarg2);
61839   arg2 = &arg2_str;
61840   arg3 = (Dali::Handle *)jarg3;
61841   if (!arg3) {
61842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61843     return 0;
61844   }
61845   {
61846     try {
61847       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
61848     } catch (std::out_of_range& e) {
61849       {
61850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61851       };
61852     } catch (std::exception& e) {
61853       {
61854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61855       };
61856     } catch (Dali::DaliException e) {
61857       {
61858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61859       };
61860     } catch (...) {
61861       {
61862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61863       };
61864     }
61865   }
61866
61867   jresult = result;
61868
61869   //argout typemap for const std::string&
61870
61871   return jresult;
61872 }
61873
61874
61875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
61876   unsigned int jresult ;
61877   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61878   Dali::Handle *arg2 = 0 ;
61879   std::string *arg3 = 0 ;
61880   bool result;
61881
61882   arg1 = (Dali::Toolkit::Builder *)jarg1;
61883   arg2 = (Dali::Handle *)jarg2;
61884   if (!arg2) {
61885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61886     return 0;
61887   }
61888   if (!jarg3) {
61889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61890     return 0;
61891   }
61892   std::string arg3_str(jarg3);
61893   arg3 = &arg3_str;
61894   {
61895     try {
61896       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
61897     } catch (std::out_of_range& e) {
61898       {
61899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61900       };
61901     } catch (std::exception& e) {
61902       {
61903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61904       };
61905     } catch (Dali::DaliException e) {
61906       {
61907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61908       };
61909     } catch (...) {
61910       {
61911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61912       };
61913     }
61914   }
61915
61916   jresult = result;
61917
61918   //argout typemap for const std::string&
61919
61920   return jresult;
61921 }
61922
61923
61924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
61925   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61926   Dali::Actor arg2 ;
61927   Dali::Actor *argp2 ;
61928
61929   arg1 = (Dali::Toolkit::Builder *)jarg1;
61930   argp2 = (Dali::Actor *)jarg2;
61931   if (!argp2) {
61932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61933     return ;
61934   }
61935   arg2 = *argp2;
61936   {
61937     try {
61938       (arg1)->AddActors(arg2);
61939     } catch (std::out_of_range& e) {
61940       {
61941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61942       };
61943     } catch (std::exception& e) {
61944       {
61945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61946       };
61947     } catch (Dali::DaliException e) {
61948       {
61949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61950       };
61951     } catch (...) {
61952       {
61953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61954       };
61955     }
61956   }
61957
61958 }
61959
61960
61961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61962   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61963   std::string *arg2 = 0 ;
61964   Dali::Actor arg3 ;
61965   Dali::Actor *argp3 ;
61966
61967   arg1 = (Dali::Toolkit::Builder *)jarg1;
61968   if (!jarg2) {
61969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61970     return ;
61971   }
61972   std::string arg2_str(jarg2);
61973   arg2 = &arg2_str;
61974   argp3 = (Dali::Actor *)jarg3;
61975   if (!argp3) {
61976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61977     return ;
61978   }
61979   arg3 = *argp3;
61980   {
61981     try {
61982       (arg1)->AddActors((std::string const &)*arg2,arg3);
61983     } catch (std::out_of_range& e) {
61984       {
61985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61986       };
61987     } catch (std::exception& e) {
61988       {
61989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61990       };
61991     } catch (Dali::DaliException e) {
61992       {
61993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61994       };
61995     } catch (...) {
61996       {
61997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61998       };
61999     }
62000   }
62001
62002
62003   //argout typemap for const std::string&
62004
62005 }
62006
62007
62008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62009   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62010   std::string *arg2 = 0 ;
62011
62012   arg1 = (Dali::Toolkit::Builder *)jarg1;
62013   if (!jarg2) {
62014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62015     return ;
62016   }
62017   std::string arg2_str(jarg2);
62018   arg2 = &arg2_str;
62019   {
62020     try {
62021       (arg1)->CreateRenderTask((std::string const &)*arg2);
62022     } catch (std::out_of_range& e) {
62023       {
62024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62025       };
62026     } catch (std::exception& e) {
62027       {
62028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62029       };
62030     } catch (Dali::DaliException e) {
62031       {
62032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62033       };
62034     } catch (...) {
62035       {
62036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62037       };
62038     }
62039   }
62040
62041
62042   //argout typemap for const std::string&
62043
62044 }
62045
62046
62047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62048   void * jresult ;
62049   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62050   std::string *arg2 = 0 ;
62051   Dali::Path result;
62052
62053   arg1 = (Dali::Toolkit::Builder *)jarg1;
62054   if (!jarg2) {
62055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62056     return 0;
62057   }
62058   std::string arg2_str(jarg2);
62059   arg2 = &arg2_str;
62060   {
62061     try {
62062       result = (arg1)->GetPath((std::string const &)*arg2);
62063     } catch (std::out_of_range& e) {
62064       {
62065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62066       };
62067     } catch (std::exception& e) {
62068       {
62069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62070       };
62071     } catch (Dali::DaliException e) {
62072       {
62073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62074       };
62075     } catch (...) {
62076       {
62077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62078       };
62079     }
62080   }
62081
62082   jresult = new Dali::Path((const Dali::Path &)result);
62083
62084   //argout typemap for const std::string&
62085
62086   return jresult;
62087 }
62088
62089
62090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62091   void * jresult ;
62092   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62093   std::string *arg2 = 0 ;
62094   Dali::PathConstrainer result;
62095
62096   arg1 = (Dali::Toolkit::Builder *)jarg1;
62097   if (!jarg2) {
62098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62099     return 0;
62100   }
62101   std::string arg2_str(jarg2);
62102   arg2 = &arg2_str;
62103   {
62104     try {
62105       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62106     } catch (std::out_of_range& e) {
62107       {
62108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62109       };
62110     } catch (std::exception& e) {
62111       {
62112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62113       };
62114     } catch (Dali::DaliException e) {
62115       {
62116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62117       };
62118     } catch (...) {
62119       {
62120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62121       };
62122     }
62123   }
62124
62125   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62126
62127   //argout typemap for const std::string&
62128
62129   return jresult;
62130 }
62131
62132
62133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62134   void * jresult ;
62135   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62136   std::string *arg2 = 0 ;
62137   Dali::LinearConstrainer result;
62138
62139   arg1 = (Dali::Toolkit::Builder *)jarg1;
62140   if (!jarg2) {
62141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62142     return 0;
62143   }
62144   std::string arg2_str(jarg2);
62145   arg2 = &arg2_str;
62146   {
62147     try {
62148       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62149     } catch (std::out_of_range& e) {
62150       {
62151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62152       };
62153     } catch (std::exception& e) {
62154       {
62155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62156       };
62157     } catch (Dali::DaliException e) {
62158       {
62159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62160       };
62161     } catch (...) {
62162       {
62163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62164       };
62165     }
62166   }
62167
62168   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62169
62170   //argout typemap for const std::string&
62171
62172   return jresult;
62173 }
62174
62175
62176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62177   void * jresult ;
62178   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62179   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62180
62181   arg1 = (Dali::Toolkit::Builder *)jarg1;
62182   {
62183     try {
62184       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62185     } catch (std::out_of_range& e) {
62186       {
62187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62188       };
62189     } catch (std::exception& e) {
62190       {
62191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62192       };
62193     } catch (Dali::DaliException e) {
62194       {
62195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62196       };
62197     } catch (...) {
62198       {
62199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62200       };
62201     }
62202   }
62203
62204   jresult = (void *)result;
62205   return jresult;
62206 }
62207
62208
62209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62210   void * jresult ;
62211   Dali::Toolkit::TransitionData *result = 0 ;
62212
62213   {
62214     try {
62215       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62216     } catch (std::out_of_range& e) {
62217       {
62218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62219       };
62220     } catch (std::exception& e) {
62221       {
62222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62223       };
62224     } catch (Dali::DaliException e) {
62225       {
62226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62227       };
62228     } catch (...) {
62229       {
62230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62231       };
62232     }
62233   }
62234
62235   jresult = (void *)result;
62236   return jresult;
62237 }
62238
62239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62240   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62241
62242   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62243   {
62244     try {
62245       delete arg1;
62246     } catch (std::out_of_range& e) {
62247       {
62248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62249       };
62250     } catch (std::exception& e) {
62251       {
62252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62253       };
62254     } catch (Dali::DaliException e) {
62255       {
62256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62257       };
62258     } catch (...) {
62259       {
62260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62261       };
62262     }
62263   }
62264
62265 }
62266
62267
62268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62269   void * jresult ;
62270   Dali::Property::Map *arg1 = 0 ;
62271   Dali::Toolkit::TransitionData result;
62272
62273   arg1 = (Dali::Property::Map *)jarg1;
62274   if (!arg1) {
62275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62276     return 0;
62277   }
62278   {
62279     try {
62280       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62281     } catch (std::out_of_range& e) {
62282       {
62283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62284       };
62285     } catch (std::exception& e) {
62286       {
62287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62288       };
62289     } catch (Dali::DaliException e) {
62290       {
62291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62292       };
62293     } catch (...) {
62294       {
62295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62296       };
62297     }
62298   }
62299
62300   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62301   return jresult;
62302 }
62303
62304
62305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62306   void * jresult ;
62307   Dali::Property::Array *arg1 = 0 ;
62308   Dali::Toolkit::TransitionData result;
62309
62310   arg1 = (Dali::Property::Array *)jarg1;
62311   if (!arg1) {
62312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62313     return 0;
62314   }
62315   {
62316     try {
62317       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62318     } catch (std::out_of_range& e) {
62319       {
62320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62321       };
62322     } catch (std::exception& e) {
62323       {
62324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62325       };
62326     } catch (Dali::DaliException e) {
62327       {
62328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62329       };
62330     } catch (...) {
62331       {
62332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62333       };
62334     }
62335   }
62336
62337   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62338   return jresult;
62339 }
62340
62341
62342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62343   void * jresult ;
62344   Dali::BaseHandle arg1 ;
62345   Dali::BaseHandle *argp1 ;
62346   Dali::Toolkit::TransitionData result;
62347
62348   argp1 = (Dali::BaseHandle *)jarg1;
62349   if (!argp1) {
62350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62351     return 0;
62352   }
62353   arg1 = *argp1;
62354   {
62355     try {
62356       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62357     } catch (std::out_of_range& e) {
62358       {
62359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62360       };
62361     } catch (std::exception& e) {
62362       {
62363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62364       };
62365     } catch (Dali::DaliException e) {
62366       {
62367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62368       };
62369     } catch (...) {
62370       {
62371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62372       };
62373     }
62374   }
62375
62376   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62377   return jresult;
62378 }
62379
62380
62381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62382   void * jresult ;
62383   Dali::Toolkit::TransitionData *arg1 = 0 ;
62384   Dali::Toolkit::TransitionData *result = 0 ;
62385
62386   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62387   if (!arg1) {
62388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62389     return 0;
62390   }
62391   {
62392     try {
62393       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62394     } catch (std::out_of_range& e) {
62395       {
62396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62397       };
62398     } catch (std::exception& e) {
62399       {
62400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62401       };
62402     } catch (Dali::DaliException e) {
62403       {
62404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62405       };
62406     } catch (...) {
62407       {
62408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62409       };
62410     }
62411   }
62412
62413   jresult = (void *)result;
62414   return jresult;
62415 }
62416
62417
62418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62419   void * jresult ;
62420   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62421   Dali::Toolkit::TransitionData *arg2 = 0 ;
62422   Dali::Toolkit::TransitionData *result = 0 ;
62423
62424   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62425   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62426   if (!arg2) {
62427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62428     return 0;
62429   }
62430   {
62431     try {
62432       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62433     } catch (std::out_of_range& e) {
62434       {
62435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62436       };
62437     } catch (std::exception& e) {
62438       {
62439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62440       };
62441     } catch (Dali::DaliException e) {
62442       {
62443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62444       };
62445     } catch (...) {
62446       {
62447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62448       };
62449     }
62450   }
62451
62452   jresult = (void *)result;
62453   return jresult;
62454 }
62455
62456
62457 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62458   unsigned long jresult ;
62459   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62460   size_t result;
62461
62462   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62463   {
62464     try {
62465       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62466     } catch (std::out_of_range& e) {
62467       {
62468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62469       };
62470     } catch (std::exception& e) {
62471       {
62472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62473       };
62474     } catch (Dali::DaliException e) {
62475       {
62476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62477       };
62478     } catch (...) {
62479       {
62480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62481       };
62482     }
62483   }
62484
62485   jresult = (unsigned long)result;
62486   return jresult;
62487 }
62488
62489
62490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62491   void * jresult ;
62492   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62493   size_t arg2 ;
62494   Dali::Property::Map result;
62495
62496   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62497   arg2 = (size_t)jarg2;
62498   {
62499     try {
62500       result = (arg1)->GetAnimatorAt(arg2);
62501     } catch (std::out_of_range& e) {
62502       {
62503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62504       };
62505     } catch (std::exception& e) {
62506       {
62507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62508       };
62509     } catch (Dali::DaliException e) {
62510       {
62511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62512       };
62513     } catch (...) {
62514       {
62515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62516       };
62517     }
62518   }
62519
62520   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62521   return jresult;
62522 }
62523
62524
62525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62526   int jresult ;
62527   int result;
62528
62529   {
62530     try {
62531       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62532     } catch (std::out_of_range& e) {
62533       {
62534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62535       };
62536     } catch (std::exception& e) {
62537       {
62538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62539       };
62540     } catch (Dali::DaliException e) {
62541       {
62542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62543       };
62544     } catch (...) {
62545       {
62546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62547       };
62548     }
62549   }
62550
62551   jresult = (int)result;
62552   return jresult;
62553 }
62554
62555
62556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62557   int jresult ;
62558   int result;
62559
62560   {
62561     try {
62562       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62563     } catch (std::out_of_range& e) {
62564       {
62565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62566       };
62567     } catch (std::exception& e) {
62568       {
62569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62570       };
62571     } catch (Dali::DaliException e) {
62572       {
62573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62574       };
62575     } catch (...) {
62576       {
62577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62578       };
62579     }
62580   }
62581
62582   jresult = (int)result;
62583   return jresult;
62584 }
62585
62586
62587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62588   int jresult ;
62589   int result;
62590
62591   {
62592     try {
62593       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62594     } catch (std::out_of_range& e) {
62595       {
62596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62597       };
62598     } catch (std::exception& e) {
62599       {
62600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62601       };
62602     } catch (Dali::DaliException e) {
62603       {
62604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62605       };
62606     } catch (...) {
62607       {
62608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62609       };
62610     }
62611   }
62612
62613   jresult = (int)result;
62614   return jresult;
62615 }
62616
62617
62618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62619   int jresult ;
62620   int result;
62621
62622   {
62623     try {
62624       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62625     } catch (std::out_of_range& e) {
62626       {
62627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62628       };
62629     } catch (std::exception& e) {
62630       {
62631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62632       };
62633     } catch (Dali::DaliException e) {
62634       {
62635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62636       };
62637     } catch (...) {
62638       {
62639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62640       };
62641     }
62642   }
62643
62644   jresult = (int)result;
62645   return jresult;
62646 }
62647
62648
62649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62650   int jresult ;
62651   int result;
62652
62653   {
62654     try {
62655       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62656     } catch (std::out_of_range& e) {
62657       {
62658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62659       };
62660     } catch (std::exception& e) {
62661       {
62662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62663       };
62664     } catch (Dali::DaliException e) {
62665       {
62666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62667       };
62668     } catch (...) {
62669       {
62670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62671       };
62672     }
62673   }
62674
62675   jresult = (int)result;
62676   return jresult;
62677 }
62678
62679
62680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62681   int jresult ;
62682   int result;
62683
62684   {
62685     try {
62686       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62687     } catch (std::out_of_range& e) {
62688       {
62689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62690       };
62691     } catch (std::exception& e) {
62692       {
62693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62694       };
62695     } catch (Dali::DaliException e) {
62696       {
62697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62698       };
62699     } catch (...) {
62700       {
62701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62702       };
62703     }
62704   }
62705
62706   jresult = (int)result;
62707   return jresult;
62708 }
62709
62710
62711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62712   int jresult ;
62713   int result;
62714
62715   {
62716     try {
62717       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62718     } catch (std::out_of_range& e) {
62719       {
62720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62721       };
62722     } catch (std::exception& e) {
62723       {
62724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62725       };
62726     } catch (Dali::DaliException e) {
62727       {
62728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62729       };
62730     } catch (...) {
62731       {
62732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62733       };
62734     }
62735   }
62736
62737   jresult = (int)result;
62738   return jresult;
62739 }
62740
62741
62742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62743   int jresult ;
62744   int result;
62745
62746   {
62747     try {
62748       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62749     } catch (std::out_of_range& e) {
62750       {
62751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62752       };
62753     } catch (std::exception& e) {
62754       {
62755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62756       };
62757     } catch (Dali::DaliException e) {
62758       {
62759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62760       };
62761     } catch (...) {
62762       {
62763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62764       };
62765     }
62766   }
62767
62768   jresult = (int)result;
62769   return jresult;
62770 }
62771
62772
62773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62774   int jresult ;
62775   int result;
62776
62777   {
62778     try {
62779       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62780     } catch (std::out_of_range& e) {
62781       {
62782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62783       };
62784     } catch (std::exception& e) {
62785       {
62786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62787       };
62788     } catch (Dali::DaliException e) {
62789       {
62790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62791       };
62792     } catch (...) {
62793       {
62794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62795       };
62796     }
62797   }
62798
62799   jresult = (int)result;
62800   return jresult;
62801 }
62802
62803
62804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
62805   int jresult ;
62806   int result;
62807
62808   {
62809     try {
62810       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
62811     } catch (std::out_of_range& e) {
62812       {
62813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62814       };
62815     } catch (std::exception& e) {
62816       {
62817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62818       };
62819     } catch (Dali::DaliException e) {
62820       {
62821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62822       };
62823     } catch (...) {
62824       {
62825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62826       };
62827     }
62828   }
62829
62830   jresult = (int)result;
62831   return jresult;
62832 }
62833
62834
62835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
62836   int jresult ;
62837   int result;
62838
62839   {
62840     try {
62841       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
62842     } catch (std::out_of_range& e) {
62843       {
62844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62845       };
62846     } catch (std::exception& e) {
62847       {
62848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62849       };
62850     } catch (Dali::DaliException e) {
62851       {
62852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62853       };
62854     } catch (...) {
62855       {
62856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62857       };
62858     }
62859   }
62860
62861   jresult = (int)result;
62862   return jresult;
62863 }
62864
62865
62866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
62867   int jresult ;
62868   int result;
62869
62870   {
62871     try {
62872       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
62873     } catch (std::out_of_range& e) {
62874       {
62875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62876       };
62877     } catch (std::exception& e) {
62878       {
62879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62880       };
62881     } catch (Dali::DaliException e) {
62882       {
62883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62884       };
62885     } catch (...) {
62886       {
62887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62888       };
62889     }
62890   }
62891
62892   jresult = (int)result;
62893   return jresult;
62894 }
62895
62896
62897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
62898   int jresult ;
62899   int result;
62900
62901   {
62902     try {
62903       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
62904     } catch (std::out_of_range& e) {
62905       {
62906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62907       };
62908     } catch (std::exception& e) {
62909       {
62910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62911       };
62912     } catch (Dali::DaliException e) {
62913       {
62914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62915       };
62916     } catch (...) {
62917       {
62918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62919       };
62920     }
62921   }
62922
62923   jresult = (int)result;
62924   return jresult;
62925 }
62926
62927
62928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
62929   int jresult ;
62930   int result;
62931
62932   {
62933     try {
62934       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
62935     } catch (std::out_of_range& e) {
62936       {
62937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62938       };
62939     } catch (std::exception& e) {
62940       {
62941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62942       };
62943     } catch (Dali::DaliException e) {
62944       {
62945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62946       };
62947     } catch (...) {
62948       {
62949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62950       };
62951     }
62952   }
62953
62954   jresult = (int)result;
62955   return jresult;
62956 }
62957
62958
62959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
62960   void * jresult ;
62961   Dali::Toolkit::Control result;
62962
62963   {
62964     try {
62965       result = Dali::Toolkit::Internal::Control::New();
62966     } catch (std::out_of_range& e) {
62967       {
62968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62969       };
62970     } catch (std::exception& e) {
62971       {
62972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62973       };
62974     } catch (Dali::DaliException e) {
62975       {
62976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62977       };
62978     } catch (...) {
62979       {
62980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62981       };
62982     }
62983   }
62984
62985   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62986   return jresult;
62987 }
62988
62989
62990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
62991   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62992   std::string *arg2 = 0 ;
62993
62994   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62995   if (!jarg2) {
62996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62997     return ;
62998   }
62999   std::string arg2_str(jarg2);
63000   arg2 = &arg2_str;
63001   {
63002     try {
63003       (arg1)->SetStyleName((std::string const &)*arg2);
63004     } catch (std::out_of_range& e) {
63005       {
63006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63007       };
63008     } catch (std::exception& e) {
63009       {
63010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63011       };
63012     } catch (Dali::DaliException e) {
63013       {
63014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63015       };
63016     } catch (...) {
63017       {
63018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63019       };
63020     }
63021   }
63022
63023
63024   //argout typemap for const std::string&
63025
63026 }
63027
63028
63029 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63030   char * jresult ;
63031   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63032   std::string *result = 0 ;
63033
63034   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63035   {
63036     try {
63037       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63038     } catch (std::out_of_range& e) {
63039       {
63040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63041       };
63042     } catch (std::exception& e) {
63043       {
63044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63045       };
63046     } catch (Dali::DaliException e) {
63047       {
63048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63049       };
63050     } catch (...) {
63051       {
63052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63053       };
63054     }
63055   }
63056
63057   jresult = SWIG_csharp_string_callback(result->c_str());
63058   return jresult;
63059 }
63060
63061
63062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63063   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63064   Dali::Vector4 *arg2 = 0 ;
63065
63066   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63067   arg2 = (Dali::Vector4 *)jarg2;
63068   if (!arg2) {
63069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63070     return ;
63071   }
63072   {
63073     try {
63074       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63075     } catch (std::out_of_range& e) {
63076       {
63077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63078       };
63079     } catch (std::exception& e) {
63080       {
63081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63082       };
63083     } catch (Dali::DaliException e) {
63084       {
63085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63086       };
63087     } catch (...) {
63088       {
63089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63090       };
63091     }
63092   }
63093
63094 }
63095
63096
63097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63098   void * jresult ;
63099   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
63100   Dali::Vector4 result;
63101
63102   arg1 = (Dali::Handle *)jarg1;
63103   {
63104     try {
63105       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
63106       if (resultMap)
63107       {
63108         if(resultMap->Find( Toolkit::Visual::Property::TYPE )->Get<int>() == Visual::COLOR )
63109         {
63110           result = resultMap->Find( ColorVisual::Property::MIX_COLOR )->Get<Vector4>();
63111         }
63112       }
63113     } catch (std::out_of_range& e) {
63114       {
63115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63116       };
63117     } catch (std::exception& e) {
63118       {
63119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63120       };
63121     } catch (Dali::DaliException e) {
63122       {
63123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63124       };
63125     } catch (...) {
63126       {
63127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63128       };
63129     }
63130   }
63131
63132   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63133   return jresult;
63134 }
63135
63136
63137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63138   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63139   Dali::Property::Map *arg2 = 0 ;
63140
63141   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63142   arg2 = (Dali::Property::Map *)jarg2;
63143   if (!arg2) {
63144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63145     return ;
63146   }
63147   {
63148     try {
63149       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63150     } catch (std::out_of_range& e) {
63151       {
63152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63153       };
63154     } catch (std::exception& e) {
63155       {
63156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63157       };
63158     } catch (Dali::DaliException e) {
63159       {
63160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63161       };
63162     } catch (...) {
63163       {
63164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63165       };
63166     }
63167   }
63168
63169 }
63170
63171
63172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63173   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63174
63175   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63176   {
63177     try {
63178       (arg1)->ClearBackground();
63179     } catch (std::out_of_range& e) {
63180       {
63181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63182       };
63183     } catch (std::exception& e) {
63184       {
63185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63186       };
63187     } catch (Dali::DaliException e) {
63188       {
63189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63190       };
63191     } catch (...) {
63192       {
63193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63194       };
63195     }
63196   }
63197
63198 }
63199
63200
63201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63202   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63203   Dali::Gesture::Type arg2 ;
63204
63205   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63206   arg2 = (Dali::Gesture::Type)jarg2;
63207   {
63208     try {
63209       (arg1)->EnableGestureDetection(arg2);
63210     } catch (std::out_of_range& e) {
63211       {
63212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63213       };
63214     } catch (std::exception& e) {
63215       {
63216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63217       };
63218     } catch (Dali::DaliException e) {
63219       {
63220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63221       };
63222     } catch (...) {
63223       {
63224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63225       };
63226     }
63227   }
63228
63229 }
63230
63231
63232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63233   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63234   Dali::Gesture::Type arg2 ;
63235
63236   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63237   arg2 = (Dali::Gesture::Type)jarg2;
63238   {
63239     try {
63240       (arg1)->DisableGestureDetection(arg2);
63241     } catch (std::out_of_range& e) {
63242       {
63243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63244       };
63245     } catch (std::exception& e) {
63246       {
63247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63248       };
63249     } catch (Dali::DaliException e) {
63250       {
63251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63252       };
63253     } catch (...) {
63254       {
63255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63256       };
63257     }
63258   }
63259
63260 }
63261
63262
63263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63264   void * jresult ;
63265   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63266   Dali::PinchGestureDetector result;
63267
63268   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63269   {
63270     try {
63271       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63272     } catch (std::out_of_range& e) {
63273       {
63274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63275       };
63276     } catch (std::exception& e) {
63277       {
63278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63279       };
63280     } catch (Dali::DaliException e) {
63281       {
63282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63283       };
63284     } catch (...) {
63285       {
63286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63287       };
63288     }
63289   }
63290
63291   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63292   return jresult;
63293 }
63294
63295
63296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63297   void * jresult ;
63298   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63299   Dali::PanGestureDetector result;
63300
63301   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63302   {
63303     try {
63304       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63305     } catch (std::out_of_range& e) {
63306       {
63307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63308       };
63309     } catch (std::exception& e) {
63310       {
63311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63312       };
63313     } catch (Dali::DaliException e) {
63314       {
63315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63316       };
63317     } catch (...) {
63318       {
63319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63320       };
63321     }
63322   }
63323
63324   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63325   return jresult;
63326 }
63327
63328
63329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63330   void * jresult ;
63331   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63332   Dali::TapGestureDetector result;
63333
63334   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63335   {
63336     try {
63337       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63338     } catch (std::out_of_range& e) {
63339       {
63340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63341       };
63342     } catch (std::exception& e) {
63343       {
63344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63345       };
63346     } catch (Dali::DaliException e) {
63347       {
63348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63349       };
63350     } catch (...) {
63351       {
63352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63353       };
63354     }
63355   }
63356
63357   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63358   return jresult;
63359 }
63360
63361
63362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63363   void * jresult ;
63364   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63365   Dali::LongPressGestureDetector result;
63366
63367   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63368   {
63369     try {
63370       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63371     } catch (std::out_of_range& e) {
63372       {
63373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63374       };
63375     } catch (std::exception& e) {
63376       {
63377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63378       };
63379     } catch (Dali::DaliException e) {
63380       {
63381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63382       };
63383     } catch (...) {
63384       {
63385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63386       };
63387     }
63388   }
63389
63390   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63391   return jresult;
63392 }
63393
63394
63395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63396   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63397   bool arg2 ;
63398
63399   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63400   arg2 = jarg2 ? true : false;
63401   {
63402     try {
63403       (arg1)->SetKeyboardNavigationSupport(arg2);
63404     } catch (std::out_of_range& e) {
63405       {
63406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63407       };
63408     } catch (std::exception& e) {
63409       {
63410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63411       };
63412     } catch (Dali::DaliException e) {
63413       {
63414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63415       };
63416     } catch (...) {
63417       {
63418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63419       };
63420     }
63421   }
63422
63423 }
63424
63425
63426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63427   unsigned int jresult ;
63428   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63429   bool result;
63430
63431   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63432   {
63433     try {
63434       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63435     } catch (std::out_of_range& e) {
63436       {
63437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63438       };
63439     } catch (std::exception& e) {
63440       {
63441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63442       };
63443     } catch (Dali::DaliException e) {
63444       {
63445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63446       };
63447     } catch (...) {
63448       {
63449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63450       };
63451     }
63452   }
63453
63454   jresult = result;
63455   return jresult;
63456 }
63457
63458
63459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63460   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63461
63462   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63463   {
63464     try {
63465       (arg1)->SetKeyInputFocus();
63466     } catch (std::out_of_range& e) {
63467       {
63468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63469       };
63470     } catch (std::exception& e) {
63471       {
63472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63473       };
63474     } catch (Dali::DaliException e) {
63475       {
63476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63477       };
63478     } catch (...) {
63479       {
63480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63481       };
63482     }
63483   }
63484
63485 }
63486
63487
63488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63489   unsigned int jresult ;
63490   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63491   bool result;
63492
63493   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63494   {
63495     try {
63496       result = (bool)(arg1)->HasKeyInputFocus();
63497     } catch (std::out_of_range& e) {
63498       {
63499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63500       };
63501     } catch (std::exception& e) {
63502       {
63503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63504       };
63505     } catch (Dali::DaliException e) {
63506       {
63507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63508       };
63509     } catch (...) {
63510       {
63511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63512       };
63513     }
63514   }
63515
63516   jresult = result;
63517   return jresult;
63518 }
63519
63520
63521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63522   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63523
63524   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63525   {
63526     try {
63527       (arg1)->ClearKeyInputFocus();
63528     } catch (std::out_of_range& e) {
63529       {
63530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63531       };
63532     } catch (std::exception& e) {
63533       {
63534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63535       };
63536     } catch (Dali::DaliException e) {
63537       {
63538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63539       };
63540     } catch (...) {
63541       {
63542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63543       };
63544     }
63545   }
63546
63547 }
63548
63549
63550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63551   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63552   bool arg2 ;
63553
63554   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63555   arg2 = jarg2 ? true : false;
63556   {
63557     try {
63558       (arg1)->SetAsKeyboardFocusGroup(arg2);
63559     } catch (std::out_of_range& e) {
63560       {
63561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63562       };
63563     } catch (std::exception& e) {
63564       {
63565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63566       };
63567     } catch (Dali::DaliException e) {
63568       {
63569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63570       };
63571     } catch (...) {
63572       {
63573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63574       };
63575     }
63576   }
63577
63578 }
63579
63580
63581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63582   unsigned int jresult ;
63583   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63584   bool result;
63585
63586   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63587   {
63588     try {
63589       result = (bool)(arg1)->IsKeyboardFocusGroup();
63590     } catch (std::out_of_range& e) {
63591       {
63592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63593       };
63594     } catch (std::exception& e) {
63595       {
63596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63597       };
63598     } catch (Dali::DaliException e) {
63599       {
63600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63601       };
63602     } catch (...) {
63603       {
63604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63605       };
63606     }
63607   }
63608
63609   jresult = result;
63610   return jresult;
63611 }
63612
63613
63614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63615   void * jresult ;
63616   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63617   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63618
63619   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63620   {
63621     try {
63622       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63623     } catch (std::out_of_range& e) {
63624       {
63625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63626       };
63627     } catch (std::exception& e) {
63628       {
63629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63630       };
63631     } catch (Dali::DaliException e) {
63632       {
63633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63634       };
63635     } catch (...) {
63636       {
63637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63638       };
63639     }
63640   }
63641
63642   jresult = (void *)result;
63643   return jresult;
63644 }
63645
63646
63647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63648   void * jresult ;
63649   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63650   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63651
63652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63653   {
63654     try {
63655       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63656     } catch (std::out_of_range& e) {
63657       {
63658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63659       };
63660     } catch (std::exception& e) {
63661       {
63662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63663       };
63664     } catch (Dali::DaliException e) {
63665       {
63666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63667       };
63668     } catch (...) {
63669       {
63670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63671       };
63672     }
63673   }
63674
63675   jresult = (void *)result;
63676   return jresult;
63677 }
63678
63679
63680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63681   void * jresult ;
63682   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63683   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63684
63685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63686   {
63687     try {
63688       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63689     } catch (std::out_of_range& e) {
63690       {
63691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63692       };
63693     } catch (std::exception& e) {
63694       {
63695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63696       };
63697     } catch (Dali::DaliException e) {
63698       {
63699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63700       };
63701     } catch (...) {
63702       {
63703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63704       };
63705     }
63706   }
63707
63708   jresult = (void *)result;
63709   return jresult;
63710 }
63711
63712
63713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63714   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63715   int arg2 ;
63716   SwigDirector_ViewImpl *darg = 0;
63717
63718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63719   arg2 = (int)jarg2;
63720   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63721   if(!darg) {
63722     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63723     return;
63724   }
63725   {
63726     try {
63727       if(darg) {
63728         (darg)->OnStageConnection(arg2);
63729       }
63730     } catch (std::out_of_range& e) {
63731       {
63732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63733       };
63734     } catch (std::exception& e) {
63735       {
63736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63737       };
63738     } catch (Dali::DaliException e) {
63739       {
63740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63741       };
63742     } catch (...) {
63743       {
63744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63745       };
63746     }
63747   }
63748
63749 }
63750
63751
63752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63753   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63754   int arg2 ;
63755   SwigDirector_ViewImpl *darg = 0;
63756
63757   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63758   arg2 = (int)jarg2;
63759   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63760   if(!darg) {
63761     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63762     return;
63763   }
63764   {
63765     try {
63766       if(darg) {
63767         (darg)->OnStageConnectionSwigPublic(arg2);
63768       }
63769     } catch (std::out_of_range& e) {
63770       {
63771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63772       };
63773     } catch (std::exception& e) {
63774       {
63775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63776       };
63777     } catch (Dali::DaliException e) {
63778       {
63779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63780       };
63781     } catch (...) {
63782       {
63783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63784       };
63785     }
63786   }
63787
63788 }
63789
63790
63791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
63792   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63793   SwigDirector_ViewImpl *darg = 0;
63794
63795   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63796   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63797   if(!darg) {
63798     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63799     return;
63800   }
63801   {
63802     try {
63803       if(darg) {
63804         (darg)->OnStageDisconnection();
63805       }
63806     } catch (std::out_of_range& e) {
63807       {
63808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63809       };
63810     } catch (std::exception& e) {
63811       {
63812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63813       };
63814     } catch (Dali::DaliException e) {
63815       {
63816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63817       };
63818     } catch (...) {
63819       {
63820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63821       };
63822     }
63823   }
63824
63825 }
63826
63827
63828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
63829   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63830   SwigDirector_ViewImpl *darg = 0;
63831
63832   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63833   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63834   if(!darg) {
63835     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63836     return;
63837   }
63838   {
63839     try {
63840       if(darg) {
63841         (darg)->OnStageDisconnectionSwigPublic();
63842       }
63843     } catch (std::out_of_range& e) {
63844       {
63845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63846       };
63847     } catch (std::exception& e) {
63848       {
63849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63850       };
63851     } catch (Dali::DaliException e) {
63852       {
63853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63854       };
63855     } catch (...) {
63856       {
63857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63858       };
63859     }
63860   }
63861
63862 }
63863
63864
63865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
63866   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63867   Dali::Actor *arg2 = 0 ;
63868   SwigDirector_ViewImpl *darg = 0;
63869
63870   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63871   arg2 = (Dali::Actor *)jarg2;
63872   if (!arg2) {
63873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63874     return ;
63875   }
63876   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63877   if(!darg) {
63878     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63879     return;
63880   }
63881   {
63882     try {
63883       if(darg) {
63884         (darg)->OnChildAdd(*arg2);
63885       }
63886     } catch (std::out_of_range& e) {
63887       {
63888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63889       };
63890     } catch (std::exception& e) {
63891       {
63892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63893       };
63894     } catch (Dali::DaliException e) {
63895       {
63896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63897       };
63898     } catch (...) {
63899       {
63900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63901       };
63902     }
63903   }
63904
63905 }
63906
63907
63908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63909   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63910   Dali::Actor *arg2 = 0 ;
63911   SwigDirector_ViewImpl *darg = 0;
63912
63913   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63914   arg2 = (Dali::Actor *)jarg2;
63915   if (!arg2) {
63916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63917     return ;
63918   }
63919   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63920   if(!darg) {
63921     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63922     return;
63923   }
63924   {
63925     try {
63926       if(darg) {
63927           (darg)->OnChildAddSwigPublic(*arg2);
63928       }
63929     } catch (std::out_of_range& e) {
63930       {
63931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63932       };
63933     } catch (std::exception& e) {
63934       {
63935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63936       };
63937     } catch (Dali::DaliException e) {
63938       {
63939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63940       };
63941     } catch (...) {
63942       {
63943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63944       };
63945     }
63946   }
63947
63948 }
63949
63950
63951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
63952   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63953   Dali::Actor *arg2 = 0 ;
63954   SwigDirector_ViewImpl *darg = 0;
63955
63956   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63957   arg2 = (Dali::Actor *)jarg2;
63958   if (!arg2) {
63959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63960     return ;
63961   }
63962   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63963   if(!darg) {
63964     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63965     return;
63966   }
63967   {
63968     try {
63969       if(darg) {
63970         (darg)->OnChildRemove(*arg2);
63971       }
63972     } catch (std::out_of_range& e) {
63973       {
63974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63975       };
63976     } catch (std::exception& e) {
63977       {
63978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63979       };
63980     } catch (Dali::DaliException e) {
63981       {
63982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63983       };
63984     } catch (...) {
63985       {
63986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63987       };
63988     }
63989   }
63990
63991 }
63992
63993
63994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63995   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63996   Dali::Actor *arg2 = 0 ;
63997   SwigDirector_ViewImpl *darg = 0;
63998
63999   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64000   arg2 = (Dali::Actor *)jarg2;
64001   if (!arg2) {
64002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64003     return ;
64004   }
64005   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64006   if(!darg) {
64007     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64008     return;
64009   }
64010   {
64011     try {
64012       if(darg) {
64013         (darg)->OnChildRemoveSwigPublic(*arg2);
64014       }
64015     } catch (std::out_of_range& e) {
64016       {
64017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64018       };
64019     } catch (std::exception& e) {
64020       {
64021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64022       };
64023     } catch (Dali::DaliException e) {
64024       {
64025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64026       };
64027     } catch (...) {
64028       {
64029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64030       };
64031     }
64032   }
64033
64034 }
64035
64036
64037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64038   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64039   Dali::Property::Index arg2 ;
64040   Dali::Property::Value arg3 ;
64041   Dali::Property::Value *argp3 ;
64042   SwigDirector_ViewImpl *darg = 0;
64043
64044   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64045   arg2 = (Dali::Property::Index)jarg2;
64046   argp3 = (Dali::Property::Value *)jarg3;
64047   if (!argp3) {
64048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64049     return ;
64050   }
64051   arg3 = *argp3;
64052   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64053   if (!darg) {
64054     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64055     return;
64056   }
64057   {
64058     try {
64059       (darg)->OnPropertySet(arg2,arg3);
64060     } catch (std::out_of_range& e) {
64061       {
64062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64063       };
64064     } catch (std::exception& e) {
64065       {
64066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64067       };
64068     } catch (Dali::DaliException e) {
64069       {
64070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64071       };
64072     } catch (...) {
64073       {
64074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64075       };
64076     }
64077   }
64078
64079 }
64080
64081
64082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64083   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64084   Dali::Property::Index arg2 ;
64085   Dali::Property::Value arg3 ;
64086   Dali::Property::Value *argp3 ;
64087   SwigDirector_ViewImpl *darg = 0;
64088
64089   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64090   arg2 = (Dali::Property::Index)jarg2;
64091   argp3 = (Dali::Property::Value *)jarg3;
64092   if (!argp3) {
64093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64094     return ;
64095   }
64096   arg3 = *argp3;
64097   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64098   if (!darg) {
64099     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64100     return;
64101   }
64102   {
64103     try {
64104       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64105     } catch (std::out_of_range& e) {
64106       {
64107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64108       };
64109     } catch (std::exception& e) {
64110       {
64111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64112       };
64113     } catch (Dali::DaliException e) {
64114       {
64115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64116       };
64117     } catch (...) {
64118       {
64119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64120       };
64121     }
64122   }
64123
64124 }
64125
64126
64127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64128   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64129   Dali::Vector3 *arg2 = 0 ;
64130   SwigDirector_ViewImpl *darg = 0;
64131
64132   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64133   arg2 = (Dali::Vector3 *)jarg2;
64134   if (!arg2) {
64135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64136     return ;
64137   }
64138   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64139   if (!darg) {
64140     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64141     return;
64142   }
64143   {
64144     try {
64145       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64146     } catch (std::out_of_range& e) {
64147       {
64148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64149       };
64150     } catch (std::exception& e) {
64151       {
64152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64153       };
64154     } catch (Dali::DaliException e) {
64155       {
64156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64157       };
64158     } catch (...) {
64159       {
64160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64161       };
64162     }
64163   }
64164
64165 }
64166
64167
64168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64169   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64170   Dali::Vector3 *arg2 = 0 ;
64171   SwigDirector_ViewImpl *darg = 0;
64172
64173   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64174   arg2 = (Dali::Vector3 *)jarg2;
64175   if (!arg2) {
64176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64177     return ;
64178   }
64179   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64180   if (!darg) {
64181     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64182     return;
64183   }
64184   {
64185     try {
64186       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64187     } catch (std::out_of_range& e) {
64188       {
64189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64190       };
64191     } catch (std::exception& e) {
64192       {
64193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64194       };
64195     } catch (Dali::DaliException e) {
64196       {
64197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64198       };
64199     } catch (...) {
64200       {
64201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64202       };
64203     }
64204   }
64205
64206 }
64207
64208
64209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64211   Dali::Animation *arg2 = 0 ;
64212   Dali::Vector3 *arg3 = 0 ;
64213   SwigDirector_ViewImpl *darg = 0;
64214
64215   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64216   arg2 = (Dali::Animation *)jarg2;
64217   if (!arg2) {
64218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64219     return ;
64220   }
64221   arg3 = (Dali::Vector3 *)jarg3;
64222   if (!arg3) {
64223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64224     return ;
64225   }
64226   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64227   if (!darg) {
64228     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64229     return;
64230   }
64231   {
64232     try {
64233       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64234     } catch (std::out_of_range& e) {
64235       {
64236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64237       };
64238     } catch (std::exception& e) {
64239       {
64240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64241       };
64242     } catch (Dali::DaliException e) {
64243       {
64244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64245       };
64246     } catch (...) {
64247       {
64248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64249       };
64250     }
64251   }
64252
64253 }
64254
64255
64256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64257   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64258   Dali::Animation *arg2 = 0 ;
64259   Dali::Vector3 *arg3 = 0 ;
64260   SwigDirector_ViewImpl *darg = 0;
64261
64262   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64263   arg2 = (Dali::Animation *)jarg2;
64264   if (!arg2) {
64265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64266     return ;
64267   }
64268   arg3 = (Dali::Vector3 *)jarg3;
64269   if (!arg3) {
64270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64271     return ;
64272   }
64273   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64274   if (!darg) {
64275     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64276     return;
64277   }
64278   {
64279     try {
64280       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64281     } catch (std::out_of_range& e) {
64282       {
64283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64284       };
64285     } catch (std::exception& e) {
64286       {
64287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64288       };
64289     } catch (Dali::DaliException e) {
64290       {
64291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64292       };
64293     } catch (...) {
64294       {
64295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64296       };
64297     }
64298   }
64299
64300 }
64301
64302
64303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64304   unsigned int jresult ;
64305   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64306   Dali::TouchEvent *arg2 = 0 ;
64307   SwigDirector_ViewImpl *darg = 0;
64308   bool result;
64309
64310   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64311   arg2 = (Dali::TouchEvent *)jarg2;
64312   if (!arg2) {
64313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64314     return 0;
64315   }
64316   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64317   if (!darg) {
64318     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64319     return 0;
64320   }
64321   {
64322     try {
64323       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64324     } catch (std::out_of_range& e) {
64325       {
64326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64327       };
64328     } catch (std::exception& e) {
64329       {
64330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64331       };
64332     } catch (Dali::DaliException e) {
64333       {
64334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64335       };
64336     } catch (...) {
64337       {
64338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64339       };
64340     }
64341   }
64342
64343   jresult = result;
64344   return jresult;
64345 }
64346
64347
64348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64349   unsigned int jresult ;
64350   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64351   Dali::TouchEvent *arg2 = 0 ;
64352   SwigDirector_ViewImpl *darg = 0;
64353   bool result;
64354
64355   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64356   arg2 = (Dali::TouchEvent *)jarg2;
64357   if (!arg2) {
64358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64359     return 0;
64360   }
64361   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64362   if (!darg) {
64363     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64364     return 0;
64365   }
64366   {
64367     try {
64368       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64369     } catch (std::out_of_range& e) {
64370       {
64371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64372       };
64373     } catch (std::exception& e) {
64374       {
64375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64376       };
64377     } catch (Dali::DaliException e) {
64378       {
64379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64380       };
64381     } catch (...) {
64382       {
64383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64384       };
64385     }
64386   }
64387
64388   jresult = result;
64389   return jresult;
64390 }
64391
64392
64393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64394   unsigned int jresult ;
64395   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64396   Dali::HoverEvent *arg2 = 0 ;
64397   SwigDirector_ViewImpl *darg = 0;
64398   bool result;
64399
64400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64401   arg2 = (Dali::HoverEvent *)jarg2;
64402   if (!arg2) {
64403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64404     return 0;
64405   }
64406   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64407   if (!darg) {
64408     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64409     return 0;
64410   }
64411   {
64412     try {
64413       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64414     } catch (std::out_of_range& e) {
64415       {
64416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64417       };
64418     } catch (std::exception& e) {
64419       {
64420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64421       };
64422     } catch (Dali::DaliException e) {
64423       {
64424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64425       };
64426     } catch (...) {
64427       {
64428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64429       };
64430     }
64431   }
64432
64433   jresult = result;
64434   return jresult;
64435 }
64436
64437
64438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64439   unsigned int jresult ;
64440   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64441   Dali::HoverEvent *arg2 = 0 ;
64442   SwigDirector_ViewImpl *darg = 0;
64443   bool result;
64444
64445   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64446   arg2 = (Dali::HoverEvent *)jarg2;
64447   if (!arg2) {
64448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64449     return 0;
64450   }
64451   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64452   if (!darg) {
64453     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64454     return 0;
64455   }
64456   {
64457     try {
64458       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64459     } catch (std::out_of_range& e) {
64460       {
64461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64462       };
64463     } catch (std::exception& e) {
64464       {
64465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64466       };
64467     } catch (Dali::DaliException e) {
64468       {
64469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64470       };
64471     } catch (...) {
64472       {
64473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64474       };
64475     }
64476   }
64477
64478   jresult = result;
64479   return jresult;
64480 }
64481
64482
64483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64484   unsigned int jresult ;
64485   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64486   Dali::KeyEvent *arg2 = 0 ;
64487   SwigDirector_ViewImpl *darg = 0;
64488   bool result;
64489
64490   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64491   arg2 = (Dali::KeyEvent *)jarg2;
64492   if (!arg2) {
64493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64494     return 0;
64495   }
64496   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64497   if (!darg) {
64498     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64499     return 0;
64500   }
64501   {
64502     try {
64503       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64504     } catch (std::out_of_range& e) {
64505       {
64506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64507       };
64508     } catch (std::exception& e) {
64509       {
64510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64511       };
64512     } catch (Dali::DaliException e) {
64513       {
64514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64515       };
64516     } catch (...) {
64517       {
64518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64519       };
64520     }
64521   }
64522
64523   jresult = result;
64524   return jresult;
64525 }
64526
64527
64528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64529   unsigned int jresult ;
64530   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64531   Dali::KeyEvent *arg2 = 0 ;
64532   SwigDirector_ViewImpl *darg = 0;
64533   bool result;
64534
64535   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64536   arg2 = (Dali::KeyEvent *)jarg2;
64537   if (!arg2) {
64538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64539     return 0;
64540   }
64541   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64542   if (!darg) {
64543     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64544     return 0;
64545   }
64546   {
64547     try {
64548       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64549     } catch (std::out_of_range& e) {
64550       {
64551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64552       };
64553     } catch (std::exception& e) {
64554       {
64555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64556       };
64557     } catch (Dali::DaliException e) {
64558       {
64559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64560       };
64561     } catch (...) {
64562       {
64563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64564       };
64565     }
64566   }
64567
64568   jresult = result;
64569   return jresult;
64570 }
64571
64572
64573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64574   unsigned int jresult ;
64575   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64576   Dali::WheelEvent *arg2 = 0 ;
64577   SwigDirector_ViewImpl *darg = 0;
64578   bool result;
64579
64580   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64581   arg2 = (Dali::WheelEvent *)jarg2;
64582   if (!arg2) {
64583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64584     return 0;
64585   }
64586   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64587   if (!darg) {
64588     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64589     return 0;
64590   }
64591   {
64592     try {
64593       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64594     } catch (std::out_of_range& e) {
64595       {
64596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64597       };
64598     } catch (std::exception& e) {
64599       {
64600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64601       };
64602     } catch (Dali::DaliException e) {
64603       {
64604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64605       };
64606     } catch (...) {
64607       {
64608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64609       };
64610     }
64611   }
64612
64613   jresult = result;
64614   return jresult;
64615 }
64616
64617
64618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64619   unsigned int jresult ;
64620   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64621   Dali::WheelEvent *arg2 = 0 ;
64622   SwigDirector_ViewImpl *darg = 0;
64623   bool result;
64624
64625   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64626   arg2 = (Dali::WheelEvent *)jarg2;
64627   if (!arg2) {
64628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64629     return 0;
64630   }
64631   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64632   if (!darg) {
64633     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64634     return 0;
64635   }
64636   {
64637     try {
64638       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64639     } catch (std::out_of_range& e) {
64640       {
64641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64642       };
64643     } catch (std::exception& e) {
64644       {
64645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64646       };
64647     } catch (Dali::DaliException e) {
64648       {
64649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64650       };
64651     } catch (...) {
64652       {
64653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64654       };
64655     }
64656   }
64657
64658   jresult = result;
64659   return jresult;
64660 }
64661
64662
64663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64664   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64665   Dali::Vector2 *arg2 = 0 ;
64666   Dali::RelayoutContainer *arg3 = 0 ;
64667   SwigDirector_ViewImpl *darg = 0;
64668
64669   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64670   arg2 = (Dali::Vector2 *)jarg2;
64671   if (!arg2) {
64672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64673     return ;
64674   }
64675   arg3 = (Dali::RelayoutContainer *)jarg3;
64676   if (!arg3) {
64677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64678     return ;
64679   }
64680   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64681   if (!darg) {
64682     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64683     return;
64684   }
64685   {
64686     try {
64687       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64688     } catch (std::out_of_range& e) {
64689       {
64690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64691       };
64692     } catch (std::exception& e) {
64693       {
64694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64695       };
64696     } catch (Dali::DaliException e) {
64697       {
64698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64699       };
64700     } catch (...) {
64701       {
64702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64703       };
64704     }
64705   }
64706
64707 }
64708
64709
64710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64711   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64712   Dali::Vector2 *arg2 = 0 ;
64713   Dali::RelayoutContainer *arg3 = 0 ;
64714   SwigDirector_ViewImpl *darg = 0;
64715
64716   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64717   arg2 = (Dali::Vector2 *)jarg2;
64718   if (!arg2) {
64719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64720     return ;
64721   }
64722   arg3 = (Dali::RelayoutContainer *)jarg3;
64723   if (!arg3) {
64724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64725     return ;
64726   }
64727   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64728   if (!darg) {
64729     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64730     return;
64731   }
64732   {
64733     try {
64734       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64735     } catch (std::out_of_range& e) {
64736       {
64737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64738       };
64739     } catch (std::exception& e) {
64740       {
64741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64742       };
64743     } catch (Dali::DaliException e) {
64744       {
64745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64746       };
64747     } catch (...) {
64748       {
64749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64750       };
64751     }
64752   }
64753
64754 }
64755
64756
64757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64758   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64759   Dali::ResizePolicy::Type arg2 ;
64760   Dali::Dimension::Type arg3 ;
64761   SwigDirector_ViewImpl *darg = 0;
64762
64763   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64764   arg2 = (Dali::ResizePolicy::Type)jarg2;
64765   arg3 = (Dali::Dimension::Type)jarg3;
64766   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64767   if (!darg) {
64768     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64769     return;
64770   }
64771   {
64772     try {
64773       (darg)->OnSetResizePolicy(arg2,arg3);
64774     } catch (std::out_of_range& e) {
64775       {
64776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64777       };
64778     } catch (std::exception& e) {
64779       {
64780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64781       };
64782     } catch (Dali::DaliException e) {
64783       {
64784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64785       };
64786     } catch (...) {
64787       {
64788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64789       };
64790     }
64791   }
64792
64793 }
64794
64795
64796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
64797   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64798   Dali::ResizePolicy::Type arg2 ;
64799   Dali::Dimension::Type arg3 ;
64800   SwigDirector_ViewImpl *darg = 0;
64801
64802   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64803   arg2 = (Dali::ResizePolicy::Type)jarg2;
64804   arg3 = (Dali::Dimension::Type)jarg3;
64805   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64806   if (!darg) {
64807     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64808     return;
64809   }
64810   {
64811     try {
64812       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
64813     } catch (std::out_of_range& e) {
64814       {
64815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64816       };
64817     } catch (std::exception& e) {
64818       {
64819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64820       };
64821     } catch (Dali::DaliException e) {
64822       {
64823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64824       };
64825     } catch (...) {
64826       {
64827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64828       };
64829     }
64830   }
64831
64832 }
64833
64834
64835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
64836   void * jresult ;
64837   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64838   SwigDirector_ViewImpl *darg = 0;
64839   Dali::Vector3 result;
64840
64841   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64842   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64843   if (!darg) {
64844     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64845     return 0;
64846   }
64847   {
64848     try {
64849       result = (darg)->GetNaturalSize();
64850     } catch (std::out_of_range& e) {
64851       {
64852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64853       };
64854     } catch (std::exception& e) {
64855       {
64856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64857       };
64858     } catch (Dali::DaliException e) {
64859       {
64860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64861       };
64862     } catch (...) {
64863       {
64864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64865       };
64866     }
64867   }
64868
64869   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64870   return jresult;
64871 }
64872
64873
64874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
64875   void * jresult ;
64876   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64877   SwigDirector_ViewImpl *darg = 0;
64878   Dali::Vector3 result;
64879
64880   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64881   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64882   if (!darg) {
64883     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64884     return 0;
64885   }
64886   {
64887     try {
64888       result = (darg)->GetNaturalSizeSwigPublic();
64889     } catch (std::out_of_range& e) {
64890       {
64891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64892       };
64893     } catch (std::exception& e) {
64894       {
64895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64896       };
64897     } catch (Dali::DaliException e) {
64898       {
64899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64900       };
64901     } catch (...) {
64902       {
64903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64904       };
64905     }
64906   }
64907
64908   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64909   return jresult;
64910 }
64911
64912
64913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
64914   float jresult ;
64915   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64916   Dali::Actor *arg2 = 0 ;
64917   Dali::Dimension::Type arg3 ;
64918   SwigDirector_ViewImpl *darg = 0;
64919   float result;
64920
64921   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64922   arg2 = (Dali::Actor *)jarg2;
64923   if (!arg2) {
64924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64925     return 0;
64926   }
64927   arg3 = (Dali::Dimension::Type)jarg3;
64928   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64929   if (!darg) {
64930     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64931     return 0;
64932   }
64933   {
64934     try {
64935       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
64936     } catch (std::out_of_range& e) {
64937       {
64938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64939       };
64940     } catch (std::exception& e) {
64941       {
64942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64943       };
64944     } catch (Dali::DaliException e) {
64945       {
64946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64947       };
64948     } catch (...) {
64949       {
64950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64951       };
64952     }
64953   }
64954
64955   jresult = result;
64956   return jresult;
64957 }
64958
64959
64960 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
64961   float jresult ;
64962   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64963   Dali::Actor *arg2 = 0 ;
64964   Dali::Dimension::Type arg3 ;
64965   SwigDirector_ViewImpl *darg = 0;
64966   float result;
64967
64968   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64969   arg2 = (Dali::Actor *)jarg2;
64970   if (!arg2) {
64971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64972     return 0;
64973   }
64974   arg3 = (Dali::Dimension::Type)jarg3;
64975   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64976   if (!darg) {
64977     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64978     return 0;
64979   }
64980   {
64981     try {
64982       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
64983     } catch (std::out_of_range& e) {
64984       {
64985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64986       };
64987     } catch (std::exception& e) {
64988       {
64989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64990       };
64991     } catch (Dali::DaliException e) {
64992       {
64993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64994       };
64995     } catch (...) {
64996       {
64997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64998       };
64999     }
65000   }
65001
65002   jresult = result;
65003   return jresult;
65004 }
65005
65006
65007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65008   float jresult ;
65009   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65010   float arg2 ;
65011   SwigDirector_ViewImpl *darg = 0;
65012   float result;
65013
65014   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65015   arg2 = (float)jarg2;
65016   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65017   if (!darg) {
65018     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65019     return 0;
65020   }
65021   {
65022     try {
65023       result = (float)(darg)->GetHeightForWidth(arg2);
65024     } catch (std::out_of_range& e) {
65025       {
65026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65027       };
65028     } catch (std::exception& e) {
65029       {
65030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65031       };
65032     } catch (Dali::DaliException e) {
65033       {
65034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65035       };
65036     } catch (...) {
65037       {
65038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65039       };
65040     }
65041   }
65042
65043   jresult = result;
65044   return jresult;
65045 }
65046
65047
65048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65049   float jresult ;
65050   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65051   float arg2 ;
65052   SwigDirector_ViewImpl *darg = 0;
65053   float result;
65054
65055   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65056   arg2 = (float)jarg2;
65057   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65058   if (!darg) {
65059     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65060     return 0;
65061   }
65062   {
65063     try {
65064       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65065     } catch (std::out_of_range& e) {
65066       {
65067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65068       };
65069     } catch (std::exception& e) {
65070       {
65071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65072       };
65073     } catch (Dali::DaliException e) {
65074       {
65075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65076       };
65077     } catch (...) {
65078       {
65079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65080       };
65081     }
65082   }
65083
65084   jresult = result;
65085   return jresult;
65086 }
65087
65088
65089 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65090   float jresult ;
65091   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65092   float arg2 ;
65093   SwigDirector_ViewImpl *darg = 0;
65094   float result;
65095
65096   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65097   arg2 = (float)jarg2;
65098   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65099   if (!darg) {
65100     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65101     return 0;
65102   }
65103   {
65104     try {
65105       result = (float)(darg)->GetWidthForHeight(arg2);
65106     } catch (std::out_of_range& e) {
65107       {
65108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65109       };
65110     } catch (std::exception& e) {
65111       {
65112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65113       };
65114     } catch (Dali::DaliException e) {
65115       {
65116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65117       };
65118     } catch (...) {
65119       {
65120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65121       };
65122     }
65123   }
65124
65125   jresult = result;
65126   return jresult;
65127 }
65128
65129
65130 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65131   float jresult ;
65132   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65133   float arg2 ;
65134   SwigDirector_ViewImpl *darg = 0;
65135   float result;
65136
65137   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65138   arg2 = (float)jarg2;
65139   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65140   if (!darg) {
65141     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65142     return 0;
65143   }
65144   {
65145     try {
65146       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65147     } catch (std::out_of_range& e) {
65148       {
65149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65150       };
65151     } catch (std::exception& e) {
65152       {
65153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65154       };
65155     } catch (Dali::DaliException e) {
65156       {
65157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65158       };
65159     } catch (...) {
65160       {
65161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65162       };
65163     }
65164   }
65165
65166   jresult = result;
65167   return jresult;
65168 }
65169
65170
65171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65172   unsigned int jresult ;
65173   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65174   Dali::Dimension::Type arg2 ;
65175   SwigDirector_ViewImpl *darg = 0;
65176   bool result;
65177
65178   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65179   arg2 = (Dali::Dimension::Type)jarg2;
65180   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65181   if (!darg) {
65182     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65183     return 0;
65184   }
65185   {
65186     try {
65187       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65188     } catch (std::out_of_range& e) {
65189       {
65190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65191       };
65192     } catch (std::exception& e) {
65193       {
65194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65195       };
65196     } catch (Dali::DaliException e) {
65197       {
65198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65199       };
65200     } catch (...) {
65201       {
65202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65203       };
65204     }
65205   }
65206
65207   jresult = result;
65208   return jresult;
65209 }
65210
65211
65212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65213   unsigned int jresult ;
65214   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65215   Dali::Dimension::Type arg2 ;
65216   SwigDirector_ViewImpl *darg = 0;
65217   bool result;
65218
65219   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65220   arg2 = (Dali::Dimension::Type)jarg2;
65221   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65222   if (!darg) {
65223     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65224     return 0;
65225   }
65226   {
65227     try {
65228       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65229     } catch (std::out_of_range& e) {
65230       {
65231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65232       };
65233     } catch (std::exception& e) {
65234       {
65235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65236       };
65237     } catch (Dali::DaliException e) {
65238       {
65239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65240       };
65241     } catch (...) {
65242       {
65243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65244       };
65245     }
65246   }
65247
65248   jresult = result;
65249   return jresult;
65250 }
65251
65252
65253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65254   unsigned int jresult ;
65255   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65256   SwigDirector_ViewImpl *darg = 0;
65257   bool result;
65258
65259   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65260   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65261   if (!darg) {
65262     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65263     return 0;
65264   }
65265   {
65266     try {
65267       result = (bool)(darg)->RelayoutDependentOnChildren();
65268     } catch (std::out_of_range& e) {
65269       {
65270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65271       };
65272     } catch (std::exception& e) {
65273       {
65274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65275       };
65276     } catch (Dali::DaliException e) {
65277       {
65278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65279       };
65280     } catch (...) {
65281       {
65282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65283       };
65284     }
65285   }
65286
65287   jresult = result;
65288   return jresult;
65289 }
65290
65291
65292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65293   unsigned int jresult ;
65294   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65295   SwigDirector_ViewImpl *darg = 0;
65296   bool result;
65297
65298   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65299   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65300   if (!darg) {
65301     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65302     return 0;
65303   }
65304   {
65305     try {
65306       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65307     } catch (std::out_of_range& e) {
65308       {
65309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65310       };
65311     } catch (std::exception& e) {
65312       {
65313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65314       };
65315     } catch (Dali::DaliException e) {
65316       {
65317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65318       };
65319     } catch (...) {
65320       {
65321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65322       };
65323     }
65324   }
65325
65326   jresult = result;
65327   return jresult;
65328 }
65329
65330
65331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65332   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65333   Dali::Dimension::Type arg2 ;
65334   SwigDirector_ViewImpl *darg = 0;
65335
65336   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65337   arg2 = (Dali::Dimension::Type)jarg2;
65338   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65339   if (!darg) {
65340     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65341     return;
65342   }
65343   {
65344     try {
65345       (darg)->OnCalculateRelayoutSize(arg2);
65346     } catch (std::out_of_range& e) {
65347       {
65348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65349       };
65350     } catch (std::exception& e) {
65351       {
65352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65353       };
65354     } catch (Dali::DaliException e) {
65355       {
65356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65357       };
65358     } catch (...) {
65359       {
65360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65361       };
65362     }
65363   }
65364
65365 }
65366
65367
65368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65369   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65370   Dali::Dimension::Type arg2 ;
65371   SwigDirector_ViewImpl *darg = 0;
65372
65373   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65374   arg2 = (Dali::Dimension::Type)jarg2;
65375   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65376   if (!darg) {
65377     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65378     return;
65379   }
65380   {
65381     try {
65382       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65383     } catch (std::out_of_range& e) {
65384       {
65385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65386       };
65387     } catch (std::exception& e) {
65388       {
65389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65390       };
65391     } catch (Dali::DaliException e) {
65392       {
65393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65394       };
65395     } catch (...) {
65396       {
65397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65398       };
65399     }
65400   }
65401
65402 }
65403
65404
65405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65406   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65407   float arg2 ;
65408   Dali::Dimension::Type arg3 ;
65409   SwigDirector_ViewImpl *darg = 0;
65410
65411   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65412   arg2 = (float)jarg2;
65413   arg3 = (Dali::Dimension::Type)jarg3;
65414   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65415   if (!darg) {
65416     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65417     return;
65418   }
65419   {
65420     try {
65421       (darg)->OnLayoutNegotiated(arg2,arg3);
65422     } catch (std::out_of_range& e) {
65423       {
65424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65425       };
65426     } catch (std::exception& e) {
65427       {
65428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65429       };
65430     } catch (Dali::DaliException e) {
65431       {
65432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65433       };
65434     } catch (...) {
65435       {
65436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65437       };
65438     }
65439   }
65440
65441 }
65442
65443
65444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65445   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65446   float arg2 ;
65447   Dali::Dimension::Type arg3 ;
65448   SwigDirector_ViewImpl *darg = 0;
65449
65450   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65451   arg2 = (float)jarg2;
65452   arg3 = (Dali::Dimension::Type)jarg3;
65453   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65454   if (!darg) {
65455     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65456     return;
65457   }
65458   {
65459     try {
65460       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65461     } catch (std::out_of_range& e) {
65462       {
65463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65464       };
65465     } catch (std::exception& e) {
65466       {
65467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65468       };
65469     } catch (Dali::DaliException e) {
65470       {
65471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65472       };
65473     } catch (...) {
65474       {
65475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65476       };
65477     }
65478   }
65479
65480 }
65481
65482
65483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65484   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65485
65486   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65487   {
65488     try {
65489       (arg1)->OnInitialize();
65490     } catch (std::out_of_range& e) {
65491       {
65492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65493       };
65494     } catch (std::exception& e) {
65495       {
65496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65497       };
65498     } catch (Dali::DaliException e) {
65499       {
65500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65501       };
65502     } catch (...) {
65503       {
65504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65505       };
65506     }
65507   }
65508
65509 }
65510
65511
65512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65513   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65514
65515   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65516   {
65517     try {
65518       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65519     } catch (std::out_of_range& e) {
65520       {
65521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65522       };
65523     } catch (std::exception& e) {
65524       {
65525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65526       };
65527     } catch (Dali::DaliException e) {
65528       {
65529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65530       };
65531     } catch (...) {
65532       {
65533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65534       };
65535     }
65536   }
65537
65538 }
65539
65540
65541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65542   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65543   Dali::Actor *arg2 = 0 ;
65544
65545   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65546   arg2 = (Dali::Actor *)jarg2;
65547   if (!arg2) {
65548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65549     return ;
65550   }
65551   {
65552     try {
65553       (arg1)->OnControlChildAdd(*arg2);
65554     } catch (std::out_of_range& e) {
65555       {
65556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65557       };
65558     } catch (std::exception& e) {
65559       {
65560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65561       };
65562     } catch (Dali::DaliException e) {
65563       {
65564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65565       };
65566     } catch (...) {
65567       {
65568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65569       };
65570     }
65571   }
65572
65573 }
65574
65575
65576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65577   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65578   Dali::Actor *arg2 = 0 ;
65579
65580   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65581   arg2 = (Dali::Actor *)jarg2;
65582   if (!arg2) {
65583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65584     return ;
65585   }
65586   {
65587     try {
65588       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65589     } catch (std::out_of_range& e) {
65590       {
65591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65592       };
65593     } catch (std::exception& e) {
65594       {
65595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65596       };
65597     } catch (Dali::DaliException e) {
65598       {
65599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65600       };
65601     } catch (...) {
65602       {
65603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65604       };
65605     }
65606   }
65607
65608 }
65609
65610
65611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65612   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65613   Dali::Actor *arg2 = 0 ;
65614
65615   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65616   arg2 = (Dali::Actor *)jarg2;
65617   if (!arg2) {
65618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65619     return ;
65620   }
65621   {
65622     try {
65623       (arg1)->OnControlChildRemove(*arg2);
65624     } catch (std::out_of_range& e) {
65625       {
65626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65627       };
65628     } catch (std::exception& e) {
65629       {
65630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65631       };
65632     } catch (Dali::DaliException e) {
65633       {
65634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65635       };
65636     } catch (...) {
65637       {
65638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65639       };
65640     }
65641   }
65642
65643 }
65644
65645
65646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65647   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65648   Dali::Actor *arg2 = 0 ;
65649
65650   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65651   arg2 = (Dali::Actor *)jarg2;
65652   if (!arg2) {
65653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65654     return ;
65655   }
65656   {
65657     try {
65658       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65659     } catch (std::out_of_range& e) {
65660       {
65661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65662       };
65663     } catch (std::exception& e) {
65664       {
65665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65666       };
65667     } catch (Dali::DaliException e) {
65668       {
65669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65670       };
65671     } catch (...) {
65672       {
65673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65674       };
65675     }
65676   }
65677
65678 }
65679
65680
65681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65682   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65683   Dali::Toolkit::StyleManager arg2 ;
65684   Dali::StyleChange::Type arg3 ;
65685   Dali::Toolkit::StyleManager *argp2 ;
65686
65687   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65688   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65689   if (!argp2) {
65690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65691     return ;
65692   }
65693   arg2 = *argp2;
65694   arg3 = (Dali::StyleChange::Type)jarg3;
65695   {
65696     try {
65697       (arg1)->OnStyleChange(arg2,arg3);
65698     } catch (std::out_of_range& e) {
65699       {
65700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65701       };
65702     } catch (std::exception& e) {
65703       {
65704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65705       };
65706     } catch (Dali::DaliException e) {
65707       {
65708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65709       };
65710     } catch (...) {
65711       {
65712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65713       };
65714     }
65715   }
65716
65717 }
65718
65719
65720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65721   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65722   Dali::Toolkit::StyleManager arg2 ;
65723   Dali::StyleChange::Type arg3 ;
65724   Dali::Toolkit::StyleManager *argp2 ;
65725
65726   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65727   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65728   if (!argp2) {
65729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65730     return ;
65731   }
65732   arg2 = *argp2;
65733   arg3 = (Dali::StyleChange::Type)jarg3;
65734   {
65735     try {
65736       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65737     } catch (std::out_of_range& e) {
65738       {
65739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65740       };
65741     } catch (std::exception& e) {
65742       {
65743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65744       };
65745     } catch (Dali::DaliException e) {
65746       {
65747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65748       };
65749     } catch (...) {
65750       {
65751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65752       };
65753     }
65754   }
65755
65756 }
65757
65758
65759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65760   unsigned int jresult ;
65761   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65762   bool result;
65763
65764   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65765   {
65766     try {
65767       result = (bool)(arg1)->OnAccessibilityActivated();
65768     } catch (std::out_of_range& e) {
65769       {
65770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65771       };
65772     } catch (std::exception& e) {
65773       {
65774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65775       };
65776     } catch (Dali::DaliException e) {
65777       {
65778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65779       };
65780     } catch (...) {
65781       {
65782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65783       };
65784     }
65785   }
65786
65787   jresult = result;
65788   return jresult;
65789 }
65790
65791
65792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
65793   unsigned int jresult ;
65794   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65795   bool result;
65796
65797   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65798   {
65799     try {
65800       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
65801     } catch (std::out_of_range& e) {
65802       {
65803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65804       };
65805     } catch (std::exception& e) {
65806       {
65807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65808       };
65809     } catch (Dali::DaliException e) {
65810       {
65811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65812       };
65813     } catch (...) {
65814       {
65815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65816       };
65817     }
65818   }
65819
65820   jresult = result;
65821   return jresult;
65822 }
65823
65824
65825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
65826   unsigned int jresult ;
65827   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65828   Dali::PanGesture arg2 ;
65829   Dali::PanGesture *argp2 ;
65830   bool result;
65831
65832   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65833   argp2 = (Dali::PanGesture *)jarg2;
65834   if (!argp2) {
65835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65836     return 0;
65837   }
65838   arg2 = *argp2;
65839   {
65840     try {
65841       result = (bool)(arg1)->OnAccessibilityPan(arg2);
65842     } catch (std::out_of_range& e) {
65843       {
65844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65845       };
65846     } catch (std::exception& e) {
65847       {
65848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65849       };
65850     } catch (Dali::DaliException e) {
65851       {
65852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65853       };
65854     } catch (...) {
65855       {
65856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65857       };
65858     }
65859   }
65860
65861   jresult = result;
65862   return jresult;
65863 }
65864
65865
65866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65867   unsigned int jresult ;
65868   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65869   Dali::PanGesture arg2 ;
65870   Dali::PanGesture *argp2 ;
65871   bool result;
65872
65873   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65874   argp2 = (Dali::PanGesture *)jarg2;
65875   if (!argp2) {
65876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65877     return 0;
65878   }
65879   arg2 = *argp2;
65880   {
65881     try {
65882       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
65883     } catch (std::out_of_range& e) {
65884       {
65885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65886       };
65887     } catch (std::exception& e) {
65888       {
65889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65890       };
65891     } catch (Dali::DaliException e) {
65892       {
65893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65894       };
65895     } catch (...) {
65896       {
65897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65898       };
65899     }
65900   }
65901
65902   jresult = result;
65903   return jresult;
65904 }
65905
65906
65907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
65908   unsigned int jresult ;
65909   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65910   Dali::TouchEvent *arg2 = 0 ;
65911   bool result;
65912
65913   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65914   arg2 = (Dali::TouchEvent *)jarg2;
65915   if (!arg2) {
65916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65917     return 0;
65918   }
65919   {
65920     try {
65921       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65922     } catch (std::out_of_range& e) {
65923       {
65924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65925       };
65926     } catch (std::exception& e) {
65927       {
65928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65929       };
65930     } catch (Dali::DaliException e) {
65931       {
65932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65933       };
65934     } catch (...) {
65935       {
65936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65937       };
65938     }
65939   }
65940
65941   jresult = result;
65942   return jresult;
65943 }
65944
65945
65946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65947   unsigned int jresult ;
65948   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65949   Dali::TouchEvent *arg2 = 0 ;
65950   bool result;
65951
65952   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65953   arg2 = (Dali::TouchEvent *)jarg2;
65954   if (!arg2) {
65955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65956     return 0;
65957   }
65958   {
65959     try {
65960       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65961     } catch (std::out_of_range& e) {
65962       {
65963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65964       };
65965     } catch (std::exception& e) {
65966       {
65967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65968       };
65969     } catch (Dali::DaliException e) {
65970       {
65971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65972       };
65973     } catch (...) {
65974       {
65975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65976       };
65977     }
65978   }
65979
65980   jresult = result;
65981   return jresult;
65982 }
65983
65984
65985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
65986   unsigned int jresult ;
65987   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65988   bool arg2 ;
65989   bool result;
65990
65991   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65992   arg2 = jarg2 ? true : false;
65993   {
65994     try {
65995       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
65996     } catch (std::out_of_range& e) {
65997       {
65998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65999       };
66000     } catch (std::exception& e) {
66001       {
66002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66003       };
66004     } catch (Dali::DaliException e) {
66005       {
66006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66007       };
66008     } catch (...) {
66009       {
66010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66011       };
66012     }
66013   }
66014
66015   jresult = result;
66016   return jresult;
66017 }
66018
66019
66020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66021   unsigned int jresult ;
66022   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66023   bool arg2 ;
66024   bool result;
66025
66026   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66027   arg2 = jarg2 ? true : false;
66028   {
66029     try {
66030       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66031     } catch (std::out_of_range& e) {
66032       {
66033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66034       };
66035     } catch (std::exception& e) {
66036       {
66037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66038       };
66039     } catch (Dali::DaliException e) {
66040       {
66041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66042       };
66043     } catch (...) {
66044       {
66045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66046       };
66047     }
66048   }
66049
66050   jresult = result;
66051   return jresult;
66052 }
66053
66054
66055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66056   unsigned int jresult ;
66057   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66058   bool result;
66059
66060   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66061   {
66062     try {
66063       result = (bool)(arg1)->OnAccessibilityZoom();
66064     } catch (std::out_of_range& e) {
66065       {
66066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66067       };
66068     } catch (std::exception& e) {
66069       {
66070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66071       };
66072     } catch (Dali::DaliException e) {
66073       {
66074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66075       };
66076     } catch (...) {
66077       {
66078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66079       };
66080     }
66081   }
66082
66083   jresult = result;
66084   return jresult;
66085 }
66086
66087
66088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66089   unsigned int jresult ;
66090   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66091   bool result;
66092
66093   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66094   {
66095     try {
66096       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66097     } catch (std::out_of_range& e) {
66098       {
66099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66100       };
66101     } catch (std::exception& e) {
66102       {
66103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66104       };
66105     } catch (Dali::DaliException e) {
66106       {
66107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66108       };
66109     } catch (...) {
66110       {
66111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66112       };
66113     }
66114   }
66115
66116   jresult = result;
66117   return jresult;
66118 }
66119
66120
66121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66122   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66123
66124   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66125   {
66126     try {
66127       (arg1)->OnKeyInputFocusGained();
66128     } catch (std::out_of_range& e) {
66129       {
66130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66131       };
66132     } catch (std::exception& e) {
66133       {
66134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66135       };
66136     } catch (Dali::DaliException e) {
66137       {
66138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66139       };
66140     } catch (...) {
66141       {
66142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66143       };
66144     }
66145   }
66146
66147 }
66148
66149
66150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66151   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66152
66153   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66154   {
66155     try {
66156       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66157     } catch (std::out_of_range& e) {
66158       {
66159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66160       };
66161     } catch (std::exception& e) {
66162       {
66163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66164       };
66165     } catch (Dali::DaliException e) {
66166       {
66167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66168       };
66169     } catch (...) {
66170       {
66171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66172       };
66173     }
66174   }
66175
66176 }
66177
66178
66179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66180   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66181
66182   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66183   {
66184     try {
66185       (arg1)->OnKeyInputFocusLost();
66186     } catch (std::out_of_range& e) {
66187       {
66188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66189       };
66190     } catch (std::exception& e) {
66191       {
66192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66193       };
66194     } catch (Dali::DaliException e) {
66195       {
66196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66197       };
66198     } catch (...) {
66199       {
66200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66201       };
66202     }
66203   }
66204
66205 }
66206
66207
66208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66209   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66210
66211   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66212   {
66213     try {
66214       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66215     } catch (std::out_of_range& e) {
66216       {
66217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66218       };
66219     } catch (std::exception& e) {
66220       {
66221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66222       };
66223     } catch (Dali::DaliException e) {
66224       {
66225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66226       };
66227     } catch (...) {
66228       {
66229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66230       };
66231     }
66232   }
66233
66234 }
66235
66236
66237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66238   void * jresult ;
66239   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66240   Dali::Actor arg2 ;
66241   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66242   bool arg4 ;
66243   Dali::Actor *argp2 ;
66244   Dali::Actor result;
66245
66246   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66247   argp2 = (Dali::Actor *)jarg2;
66248   if (!argp2) {
66249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66250     return 0;
66251   }
66252   arg2 = *argp2;
66253   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66254   arg4 = jarg4 ? true : false;
66255   {
66256     try {
66257       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66258     } catch (std::out_of_range& e) {
66259       {
66260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66261       };
66262     } catch (std::exception& e) {
66263       {
66264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66265       };
66266     } catch (Dali::DaliException e) {
66267       {
66268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66269       };
66270     } catch (...) {
66271       {
66272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66273       };
66274     }
66275   }
66276
66277   jresult = new Dali::Actor((const Dali::Actor &)result);
66278   return jresult;
66279 }
66280
66281
66282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66283   void * jresult ;
66284   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66285   Dali::Actor arg2 ;
66286   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66287   bool arg4 ;
66288   Dali::Actor *argp2 ;
66289   Dali::Actor result;
66290
66291   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66292   argp2 = (Dali::Actor *)jarg2;
66293   if (!argp2) {
66294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66295     return 0;
66296   }
66297   arg2 = *argp2;
66298   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66299   arg4 = jarg4 ? true : false;
66300   {
66301     try {
66302       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66303     } catch (std::out_of_range& e) {
66304       {
66305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66306       };
66307     } catch (std::exception& e) {
66308       {
66309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66310       };
66311     } catch (Dali::DaliException e) {
66312       {
66313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66314       };
66315     } catch (...) {
66316       {
66317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66318       };
66319     }
66320   }
66321
66322   jresult = new Dali::Actor((const Dali::Actor &)result);
66323   return jresult;
66324 }
66325
66326
66327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66328   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66329   Dali::Actor arg2 ;
66330   Dali::Actor *argp2 ;
66331
66332   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66333   argp2 = (Dali::Actor *)jarg2;
66334   if (!argp2) {
66335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66336     return ;
66337   }
66338   arg2 = *argp2;
66339   {
66340     try {
66341       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66342     } catch (std::out_of_range& e) {
66343       {
66344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66345       };
66346     } catch (std::exception& e) {
66347       {
66348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66349       };
66350     } catch (Dali::DaliException e) {
66351       {
66352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66353       };
66354     } catch (...) {
66355       {
66356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66357       };
66358     }
66359   }
66360
66361 }
66362
66363
66364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66365   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66366   Dali::Actor arg2 ;
66367   Dali::Actor *argp2 ;
66368
66369   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66370   argp2 = (Dali::Actor *)jarg2;
66371   if (!argp2) {
66372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66373     return ;
66374   }
66375   arg2 = *argp2;
66376   {
66377     try {
66378       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66379     } catch (std::out_of_range& e) {
66380       {
66381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66382       };
66383     } catch (std::exception& e) {
66384       {
66385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66386       };
66387     } catch (Dali::DaliException e) {
66388       {
66389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66390       };
66391     } catch (...) {
66392       {
66393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66394       };
66395     }
66396   }
66397
66398 }
66399
66400
66401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66402   unsigned int jresult ;
66403   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66404   bool result;
66405
66406   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66407   {
66408     try {
66409       result = (bool)(arg1)->OnKeyboardEnter();
66410     } catch (std::out_of_range& e) {
66411       {
66412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66413       };
66414     } catch (std::exception& e) {
66415       {
66416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66417       };
66418     } catch (Dali::DaliException e) {
66419       {
66420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66421       };
66422     } catch (...) {
66423       {
66424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66425       };
66426     }
66427   }
66428
66429   jresult = result;
66430   return jresult;
66431 }
66432
66433
66434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66435   unsigned int jresult ;
66436   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66437   bool result;
66438
66439   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66440   {
66441     try {
66442       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66443     } catch (std::out_of_range& e) {
66444       {
66445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66446       };
66447     } catch (std::exception& e) {
66448       {
66449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66450       };
66451     } catch (Dali::DaliException e) {
66452       {
66453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66454       };
66455     } catch (...) {
66456       {
66457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66458       };
66459     }
66460   }
66461
66462   jresult = result;
66463   return jresult;
66464 }
66465
66466
66467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66468   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66469   Dali::PinchGesture *arg2 = 0 ;
66470
66471   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66472   arg2 = (Dali::PinchGesture *)jarg2;
66473   if (!arg2) {
66474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66475     return ;
66476   }
66477   {
66478     try {
66479       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66480     } catch (std::out_of_range& e) {
66481       {
66482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66483       };
66484     } catch (std::exception& e) {
66485       {
66486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66487       };
66488     } catch (Dali::DaliException e) {
66489       {
66490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66491       };
66492     } catch (...) {
66493       {
66494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66495       };
66496     }
66497   }
66498
66499 }
66500
66501
66502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66503   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66504   Dali::PinchGesture *arg2 = 0 ;
66505
66506   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66507   arg2 = (Dali::PinchGesture *)jarg2;
66508   if (!arg2) {
66509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66510     return ;
66511   }
66512   {
66513     try {
66514       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66515     } catch (std::out_of_range& e) {
66516       {
66517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66518       };
66519     } catch (std::exception& e) {
66520       {
66521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66522       };
66523     } catch (Dali::DaliException e) {
66524       {
66525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66526       };
66527     } catch (...) {
66528       {
66529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66530       };
66531     }
66532   }
66533
66534 }
66535
66536
66537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66538   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66539   Dali::PanGesture *arg2 = 0 ;
66540
66541   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66542   arg2 = (Dali::PanGesture *)jarg2;
66543   if (!arg2) {
66544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66545     return ;
66546   }
66547   {
66548     try {
66549       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66550     } catch (std::out_of_range& e) {
66551       {
66552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66553       };
66554     } catch (std::exception& e) {
66555       {
66556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66557       };
66558     } catch (Dali::DaliException e) {
66559       {
66560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66561       };
66562     } catch (...) {
66563       {
66564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66565       };
66566     }
66567   }
66568
66569 }
66570
66571
66572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66573   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66574   Dali::PanGesture *arg2 = 0 ;
66575
66576   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66577   arg2 = (Dali::PanGesture *)jarg2;
66578   if (!arg2) {
66579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66580     return ;
66581   }
66582   {
66583     try {
66584       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66585     } catch (std::out_of_range& e) {
66586       {
66587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66588       };
66589     } catch (std::exception& e) {
66590       {
66591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66592       };
66593     } catch (Dali::DaliException e) {
66594       {
66595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66596       };
66597     } catch (...) {
66598       {
66599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66600       };
66601     }
66602   }
66603
66604 }
66605
66606
66607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66608   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66609   Dali::TapGesture *arg2 = 0 ;
66610
66611   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66612   arg2 = (Dali::TapGesture *)jarg2;
66613   if (!arg2) {
66614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66615     return ;
66616   }
66617   {
66618     try {
66619       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66620     } catch (std::out_of_range& e) {
66621       {
66622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66623       };
66624     } catch (std::exception& e) {
66625       {
66626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66627       };
66628     } catch (Dali::DaliException e) {
66629       {
66630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66631       };
66632     } catch (...) {
66633       {
66634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66635       };
66636     }
66637   }
66638
66639 }
66640
66641
66642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66643   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66644   Dali::TapGesture *arg2 = 0 ;
66645
66646   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66647   arg2 = (Dali::TapGesture *)jarg2;
66648   if (!arg2) {
66649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66650     return ;
66651   }
66652   {
66653     try {
66654       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66655     } catch (std::out_of_range& e) {
66656       {
66657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66658       };
66659     } catch (std::exception& e) {
66660       {
66661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66662       };
66663     } catch (Dali::DaliException e) {
66664       {
66665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66666       };
66667     } catch (...) {
66668       {
66669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66670       };
66671     }
66672   }
66673
66674 }
66675
66676
66677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66678   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66679   Dali::LongPressGesture *arg2 = 0 ;
66680
66681   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66682   arg2 = (Dali::LongPressGesture *)jarg2;
66683   if (!arg2) {
66684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66685     return ;
66686   }
66687   {
66688     try {
66689       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66690     } catch (std::out_of_range& e) {
66691       {
66692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66693       };
66694     } catch (std::exception& e) {
66695       {
66696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66697       };
66698     } catch (Dali::DaliException e) {
66699       {
66700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66701       };
66702     } catch (...) {
66703       {
66704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66705       };
66706     }
66707   }
66708
66709 }
66710
66711
66712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66713   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66714   Dali::LongPressGesture *arg2 = 0 ;
66715
66716   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66717   arg2 = (Dali::LongPressGesture *)jarg2;
66718   if (!arg2) {
66719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66720     return ;
66721   }
66722   {
66723     try {
66724       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66725     } catch (std::out_of_range& e) {
66726       {
66727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66728       };
66729     } catch (std::exception& e) {
66730       {
66731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66732       };
66733     } catch (Dali::DaliException e) {
66734       {
66735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66736       };
66737     } catch (...) {
66738       {
66739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66740       };
66741     }
66742   }
66743
66744 }
66745
66746
66747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66748   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66749   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66750   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66751
66752   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66753   arg2 = (Dali::SlotObserver *)jarg2;
66754   arg3 = (Dali::CallbackBase *)jarg3;
66755   {
66756     try {
66757       (arg1)->SignalConnected(arg2,arg3);
66758     } catch (std::out_of_range& e) {
66759       {
66760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66761       };
66762     } catch (std::exception& e) {
66763       {
66764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66765       };
66766     } catch (Dali::DaliException e) {
66767       {
66768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66769       };
66770     } catch (...) {
66771       {
66772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66773       };
66774     }
66775   }
66776
66777 }
66778
66779
66780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66781   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66782   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66783   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66784
66785   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66786   arg2 = (Dali::SlotObserver *)jarg2;
66787   arg3 = (Dali::CallbackBase *)jarg3;
66788   {
66789     try {
66790       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
66791     } catch (std::out_of_range& e) {
66792       {
66793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66794       };
66795     } catch (std::exception& e) {
66796       {
66797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66798       };
66799     } catch (Dali::DaliException e) {
66800       {
66801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66802       };
66803     } catch (...) {
66804       {
66805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66806       };
66807     }
66808   }
66809
66810 }
66811
66812
66813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
66814   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66815   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66816   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66817
66818   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66819   arg2 = (Dali::SlotObserver *)jarg2;
66820   arg3 = (Dali::CallbackBase *)jarg3;
66821   {
66822     try {
66823       (arg1)->SignalDisconnected(arg2,arg3);
66824     } catch (std::out_of_range& e) {
66825       {
66826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66827       };
66828     } catch (std::exception& e) {
66829       {
66830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66831       };
66832     } catch (Dali::DaliException e) {
66833       {
66834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66835       };
66836     } catch (...) {
66837       {
66838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66839       };
66840     }
66841   }
66842
66843 }
66844
66845
66846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66847   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66848   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66849   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66850
66851   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66852   arg2 = (Dali::SlotObserver *)jarg2;
66853   arg3 = (Dali::CallbackBase *)jarg3;
66854   {
66855     try {
66856       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
66857     } catch (std::out_of_range& e) {
66858       {
66859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66860       };
66861     } catch (std::exception& e) {
66862       {
66863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66864       };
66865     } catch (Dali::DaliException e) {
66866       {
66867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66868       };
66869     } catch (...) {
66870       {
66871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66872       };
66873     }
66874   }
66875
66876 }
66877
66878
66879 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) {
66880   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
66881   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
66882   if (director) {
66883     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);
66884   }
66885 }
66886
66887
66888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
66889   void * jresult ;
66890   Dali::Toolkit::Control *arg1 = 0 ;
66891   Dali::Toolkit::Internal::Control *result = 0 ;
66892
66893   arg1 = (Dali::Toolkit::Control *)jarg1;
66894   if (!arg1) {
66895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66896     return 0;
66897   }
66898   {
66899     try {
66900       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
66901     } catch (std::out_of_range& e) {
66902       {
66903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66904       };
66905     } catch (std::exception& e) {
66906       {
66907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66908       };
66909     } catch (Dali::DaliException e) {
66910       {
66911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66912       };
66913     } catch (...) {
66914       {
66915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66916       };
66917     }
66918   }
66919
66920   jresult = (void *)result;
66921   return jresult;
66922 }
66923
66924
66925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
66926   int jresult ;
66927   int result;
66928
66929   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
66930   jresult = (int)result;
66931   return jresult;
66932 }
66933
66934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
66935   int jresult ;
66936   int result;
66937
66938   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
66939   jresult = (int)result;
66940   return jresult;
66941 }
66942
66943
66944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
66945   int jresult ;
66946   int result;
66947
66948   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
66949   jresult = (int)result;
66950   return jresult;
66951 }
66952
66953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
66954   int jresult ;
66955   int result;
66956
66957   result = (int)Dali::Toolkit::Control::Property::MARGIN;
66958   jresult = (int)result;
66959   return jresult;
66960 }
66961
66962
66963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
66964   int jresult ;
66965   int result;
66966
66967   result = (int)Dali::Toolkit::Control::Property::PADDING;
66968   jresult = (int)result;
66969   return jresult;
66970 }
66971
66972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
66973   void * jresult ;
66974   Dali::Toolkit::Control::Property *result = 0 ;
66975
66976   {
66977     try {
66978       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
66979     } catch (std::out_of_range& e) {
66980       {
66981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66982       };
66983     } catch (std::exception& e) {
66984       {
66985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66986       };
66987     } catch (Dali::DaliException e) {
66988       {
66989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66990       };
66991     } catch (...) {
66992       {
66993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66994       };
66995     }
66996   }
66997
66998   jresult = (void *)result;
66999   return jresult;
67000 }
67001
67002
67003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67004   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67005
67006   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67007   {
67008     try {
67009       delete arg1;
67010     } catch (std::out_of_range& e) {
67011       {
67012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67013       };
67014     } catch (std::exception& e) {
67015       {
67016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67017       };
67018     } catch (Dali::DaliException e) {
67019       {
67020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67021       };
67022     } catch (...) {
67023       {
67024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67025       };
67026     }
67027   }
67028
67029 }
67030
67031
67032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67033   void * jresult ;
67034   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67035
67036   {
67037     try {
67038       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67039     } catch (std::out_of_range& e) {
67040       {
67041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67042       };
67043     } catch (std::exception& e) {
67044       {
67045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67046       };
67047     } catch (Dali::DaliException e) {
67048       {
67049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67050       };
67051     } catch (...) {
67052       {
67053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67054       };
67055     }
67056   }
67057
67058   jresult = (void *)result;
67059   return jresult;
67060 }
67061
67062
67063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67064   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67065
67066   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67067   {
67068     try {
67069       delete arg1;
67070     } catch (std::out_of_range& e) {
67071       {
67072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67073       };
67074     } catch (std::exception& e) {
67075       {
67076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67077       };
67078     } catch (Dali::DaliException e) {
67079       {
67080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67081       };
67082     } catch (...) {
67083       {
67084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67085       };
67086     }
67087   }
67088
67089 }
67090
67091
67092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67093   void * jresult ;
67094   Dali::Toolkit::Control result;
67095
67096   {
67097     try {
67098       result = Dali::Toolkit::Control::New();
67099     } catch (std::out_of_range& e) {
67100       {
67101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67102       };
67103     } catch (std::exception& e) {
67104       {
67105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67106       };
67107     } catch (Dali::DaliException e) {
67108       {
67109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67110       };
67111     } catch (...) {
67112       {
67113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67114       };
67115     }
67116   }
67117
67118   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67119   return jresult;
67120 }
67121
67122
67123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67124   void * jresult ;
67125   Dali::Toolkit::Control *result = 0 ;
67126
67127   {
67128     try {
67129       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67130     } catch (std::out_of_range& e) {
67131       {
67132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67133       };
67134     } catch (std::exception& e) {
67135       {
67136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67137       };
67138     } catch (Dali::DaliException e) {
67139       {
67140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67141       };
67142     } catch (...) {
67143       {
67144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67145       };
67146     }
67147   }
67148
67149   jresult = (void *)result;
67150   return jresult;
67151 }
67152
67153
67154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67155   void * jresult ;
67156   Dali::Toolkit::Control *arg1 = 0 ;
67157   Dali::Toolkit::Control *result = 0 ;
67158
67159   arg1 = (Dali::Toolkit::Control *)jarg1;
67160   if (!arg1) {
67161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67162     return 0;
67163   }
67164   {
67165     try {
67166       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67167     } catch (std::out_of_range& e) {
67168       {
67169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67170       };
67171     } catch (std::exception& e) {
67172       {
67173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67174       };
67175     } catch (Dali::DaliException e) {
67176       {
67177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67178       };
67179     } catch (...) {
67180       {
67181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67182       };
67183     }
67184   }
67185
67186   jresult = (void *)result;
67187   return jresult;
67188 }
67189
67190
67191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67192   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67193
67194   arg1 = (Dali::Toolkit::Control *)jarg1;
67195   {
67196     try {
67197       delete arg1;
67198     } catch (std::out_of_range& e) {
67199       {
67200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67201       };
67202     } catch (std::exception& e) {
67203       {
67204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67205       };
67206     } catch (Dali::DaliException e) {
67207       {
67208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67209       };
67210     } catch (...) {
67211       {
67212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67213       };
67214     }
67215   }
67216
67217 }
67218
67219
67220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67221   void * jresult ;
67222   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67223   Dali::Toolkit::Control *arg2 = 0 ;
67224   Dali::Toolkit::Control *result = 0 ;
67225
67226   arg1 = (Dali::Toolkit::Control *)jarg1;
67227   arg2 = (Dali::Toolkit::Control *)jarg2;
67228   if (!arg2) {
67229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67230     return 0;
67231   }
67232   {
67233     try {
67234       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67235     } catch (std::out_of_range& e) {
67236       {
67237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67238       };
67239     } catch (std::exception& e) {
67240       {
67241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67242       };
67243     } catch (Dali::DaliException e) {
67244       {
67245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67246       };
67247     } catch (...) {
67248       {
67249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67250       };
67251     }
67252   }
67253
67254   jresult = (void *)result;
67255   return jresult;
67256 }
67257
67258
67259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67260   void * jresult ;
67261   Dali::BaseHandle arg1 ;
67262   Dali::BaseHandle *argp1 ;
67263   Dali::Toolkit::Control result;
67264
67265   argp1 = (Dali::BaseHandle *)jarg1;
67266   if (!argp1) {
67267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67268     return 0;
67269   }
67270   arg1 = *argp1;
67271   {
67272     try {
67273       result = Dali::Toolkit::Control::DownCast(arg1);
67274     } catch (std::out_of_range& e) {
67275       {
67276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67277       };
67278     } catch (std::exception& e) {
67279       {
67280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67281       };
67282     } catch (Dali::DaliException e) {
67283       {
67284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67285       };
67286     } catch (...) {
67287       {
67288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67289       };
67290     }
67291   }
67292
67293   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67294   return jresult;
67295 }
67296
67297
67298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67299   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67300
67301   arg1 = (Dali::Toolkit::Control *)jarg1;
67302   {
67303     try {
67304       (arg1)->SetKeyInputFocus();
67305     } catch (std::out_of_range& e) {
67306       {
67307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67308       };
67309     } catch (std::exception& e) {
67310       {
67311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67312       };
67313     } catch (Dali::DaliException e) {
67314       {
67315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67316       };
67317     } catch (...) {
67318       {
67319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67320       };
67321     }
67322   }
67323
67324 }
67325
67326
67327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67328   unsigned int jresult ;
67329   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67330   bool result;
67331
67332   arg1 = (Dali::Toolkit::Control *)jarg1;
67333   {
67334     try {
67335       result = (bool)(arg1)->HasKeyInputFocus();
67336     } catch (std::out_of_range& e) {
67337       {
67338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67339       };
67340     } catch (std::exception& e) {
67341       {
67342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67343       };
67344     } catch (Dali::DaliException e) {
67345       {
67346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67347       };
67348     } catch (...) {
67349       {
67350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67351       };
67352     }
67353   }
67354
67355   jresult = result;
67356   return jresult;
67357 }
67358
67359
67360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67361   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67362
67363   arg1 = (Dali::Toolkit::Control *)jarg1;
67364   {
67365     try {
67366       (arg1)->ClearKeyInputFocus();
67367     } catch (std::out_of_range& e) {
67368       {
67369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67370       };
67371     } catch (std::exception& e) {
67372       {
67373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67374       };
67375     } catch (Dali::DaliException e) {
67376       {
67377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67378       };
67379     } catch (...) {
67380       {
67381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67382       };
67383     }
67384   }
67385
67386 }
67387
67388
67389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67390   void * jresult ;
67391   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67392   Dali::PinchGestureDetector result;
67393
67394   arg1 = (Dali::Toolkit::Control *)jarg1;
67395   {
67396     try {
67397       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67398     } catch (std::out_of_range& e) {
67399       {
67400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67401       };
67402     } catch (std::exception& e) {
67403       {
67404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67405       };
67406     } catch (Dali::DaliException e) {
67407       {
67408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67409       };
67410     } catch (...) {
67411       {
67412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67413       };
67414     }
67415   }
67416
67417   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67418   return jresult;
67419 }
67420
67421
67422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67423   void * jresult ;
67424   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67425   Dali::PanGestureDetector result;
67426
67427   arg1 = (Dali::Toolkit::Control *)jarg1;
67428   {
67429     try {
67430       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67431     } catch (std::out_of_range& e) {
67432       {
67433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67434       };
67435     } catch (std::exception& e) {
67436       {
67437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67438       };
67439     } catch (Dali::DaliException e) {
67440       {
67441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67442       };
67443     } catch (...) {
67444       {
67445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67446       };
67447     }
67448   }
67449
67450   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67451   return jresult;
67452 }
67453
67454
67455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67456   void * jresult ;
67457   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67458   Dali::TapGestureDetector result;
67459
67460   arg1 = (Dali::Toolkit::Control *)jarg1;
67461   {
67462     try {
67463       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67464     } catch (std::out_of_range& e) {
67465       {
67466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67467       };
67468     } catch (std::exception& e) {
67469       {
67470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67471       };
67472     } catch (Dali::DaliException e) {
67473       {
67474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67475       };
67476     } catch (...) {
67477       {
67478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67479       };
67480     }
67481   }
67482
67483   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67484   return jresult;
67485 }
67486
67487
67488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67489   void * jresult ;
67490   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67491   Dali::LongPressGestureDetector result;
67492
67493   arg1 = (Dali::Toolkit::Control *)jarg1;
67494   {
67495     try {
67496       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67497     } catch (std::out_of_range& e) {
67498       {
67499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67500       };
67501     } catch (std::exception& e) {
67502       {
67503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67504       };
67505     } catch (Dali::DaliException e) {
67506       {
67507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67508       };
67509     } catch (...) {
67510       {
67511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67512       };
67513     }
67514   }
67515
67516   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67517   return jresult;
67518 }
67519
67520
67521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67522   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67523   std::string *arg2 = 0 ;
67524
67525   arg1 = (Dali::Toolkit::Control *)jarg1;
67526   if (!jarg2) {
67527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67528     return ;
67529   }
67530   std::string arg2_str(jarg2);
67531   arg2 = &arg2_str;
67532   {
67533     try {
67534       (arg1)->SetStyleName((std::string const &)*arg2);
67535     } catch (std::out_of_range& e) {
67536       {
67537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67538       };
67539     } catch (std::exception& e) {
67540       {
67541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67542       };
67543     } catch (Dali::DaliException e) {
67544       {
67545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67546       };
67547     } catch (...) {
67548       {
67549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67550       };
67551     }
67552   }
67553
67554
67555   //argout typemap for const std::string&
67556
67557 }
67558
67559
67560 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67561   char * jresult ;
67562   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67563   std::string *result = 0 ;
67564
67565   arg1 = (Dali::Toolkit::Control *)jarg1;
67566   {
67567     try {
67568       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67569     } catch (std::out_of_range& e) {
67570       {
67571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67572       };
67573     } catch (std::exception& e) {
67574       {
67575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67576       };
67577     } catch (Dali::DaliException e) {
67578       {
67579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67580       };
67581     } catch (...) {
67582       {
67583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67584       };
67585     }
67586   }
67587
67588   jresult = SWIG_csharp_string_callback(result->c_str());
67589   return jresult;
67590 }
67591
67592
67593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67594   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67595   Dali::Vector4 *arg2 = 0 ;
67596
67597   arg1 = (Dali::Toolkit::Control *)jarg1;
67598   arg2 = (Dali::Vector4 *)jarg2;
67599   if (!arg2) {
67600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67601     return ;
67602   }
67603   {
67604     try {
67605       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67606     } catch (std::out_of_range& e) {
67607       {
67608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67609       };
67610     } catch (std::exception& e) {
67611       {
67612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67613       };
67614     } catch (Dali::DaliException e) {
67615       {
67616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67617       };
67618     } catch (...) {
67619       {
67620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67621       };
67622     }
67623   }
67624
67625 }
67626
67627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67628   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67629
67630   arg1 = (Dali::Toolkit::Control *)jarg1;
67631   {
67632     try {
67633       (arg1)->ClearBackground();
67634     } catch (std::out_of_range& e) {
67635       {
67636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67637       };
67638     } catch (std::exception& e) {
67639       {
67640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67641       };
67642     } catch (Dali::DaliException e) {
67643       {
67644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67645       };
67646     } catch (...) {
67647       {
67648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67649       };
67650     }
67651   }
67652
67653 }
67654
67655
67656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67657   void * jresult ;
67658   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67659   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67660
67661   arg1 = (Dali::Toolkit::Control *)jarg1;
67662   {
67663     try {
67664       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67665     } catch (std::out_of_range& e) {
67666       {
67667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67668       };
67669     } catch (std::exception& e) {
67670       {
67671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67672       };
67673     } catch (Dali::DaliException e) {
67674       {
67675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67676       };
67677     } catch (...) {
67678       {
67679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67680       };
67681     }
67682   }
67683
67684   jresult = (void *)result;
67685   return jresult;
67686 }
67687
67688
67689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
67690   void * jresult ;
67691   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67692   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67693
67694   arg1 = (Dali::Toolkit::Control *)jarg1;
67695   {
67696     try {
67697       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
67698     } catch (std::out_of_range& e) {
67699       {
67700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67701       };
67702     } catch (std::exception& e) {
67703       {
67704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67705       };
67706     } catch (Dali::DaliException e) {
67707       {
67708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67709       };
67710     } catch (...) {
67711       {
67712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67713       };
67714     }
67715   }
67716
67717   jresult = (void *)result;
67718   return jresult;
67719 }
67720
67721
67722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
67723   void * jresult ;
67724   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67725   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67726
67727   arg1 = (Dali::Toolkit::Control *)jarg1;
67728   {
67729     try {
67730       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
67731     } catch (std::out_of_range& e) {
67732       {
67733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67734       };
67735     } catch (std::exception& e) {
67736       {
67737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67738       };
67739     } catch (Dali::DaliException e) {
67740       {
67741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67742       };
67743     } catch (...) {
67744       {
67745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67746       };
67747     }
67748   }
67749
67750   jresult = (void *)result;
67751   return jresult;
67752 }
67753
67754
67755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
67756   void * jresult ;
67757   Dali::Toolkit::Internal::Control *arg1 = 0 ;
67758   Dali::Toolkit::Control *result = 0 ;
67759
67760   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67761   if (!arg1) {
67762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
67763     return 0;
67764   }
67765   {
67766     try {
67767       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
67768     } catch (std::out_of_range& e) {
67769       {
67770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67771       };
67772     } catch (std::exception& e) {
67773       {
67774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67775       };
67776     } catch (Dali::DaliException e) {
67777       {
67778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67779       };
67780     } catch (...) {
67781       {
67782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67783       };
67784     }
67785   }
67786
67787   jresult = (void *)result;
67788   return jresult;
67789 }
67790
67791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
67792 {
67793   int jresult;
67794   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67795   arg1 = (Dali::Toolkit::Control *)jarg1;
67796
67797   if (!arg1) {
67798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67799     return 0;
67800   }
67801
67802   Dali::Property::Index arg2 = 0 ;
67803   arg2 = (Dali::Property::Index)jarg2;
67804
67805   Toolkit::Visual::ResourceStatus result;
67806   {
67807     try {
67808       result = arg1->GetVisualResourceStatus(arg2);
67809     } catch (std::out_of_range& e) {
67810       {
67811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67812       };
67813     } catch (std::exception& e) {
67814       {
67815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67816       };
67817     } catch (...) {
67818       {
67819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67820       };
67821     }
67822   }
67823   jresult = (int)(result);
67824   return jresult;
67825 }
67826
67827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
67828 {
67829   void * jresult;
67830   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67831   arg1 = (Dali::Toolkit::Control *)jarg1;
67832
67833   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
67834
67835   Dali::Toolkit::TransitionData *arg2 = 0 ;
67836   Dali::Animation result;
67837
67838   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
67839   if (!arg2) {
67840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
67841     return 0;
67842   }
67843   {
67844     try {
67845       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
67846     } catch (std::out_of_range& e) {
67847       {
67848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67849       };
67850     } catch (std::exception& e) {
67851       {
67852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67853       };
67854     } catch (Dali::DaliException e) {
67855       {
67856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67857       };
67858     } catch (...) {
67859       {
67860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67861       };
67862     }
67863   }
67864
67865   jresult = new Dali::Animation((const Dali::Animation &)result);
67866   return jresult;
67867 }
67868
67869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
67870 {
67871   Dali::Toolkit::Control arg1;
67872   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
67873
67874   if (!argp1) {
67875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67876   }
67877   arg1 = *argp1;
67878
67879   Dali::Property::Index arg2 = 0 ;
67880   arg2 = (Dali::Property::Index)jarg2;
67881
67882   Dali::Property::Index arg3 = 0 ;
67883   arg3 = (Dali::Property::Index)jarg3;
67884
67885   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
67886
67887   {
67888     try {
67889       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
67890     } catch (std::out_of_range& e) {
67891       {
67892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67893       };
67894     } catch (std::exception& e) {
67895       {
67896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67897       };
67898     } catch (...) {
67899       {
67900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67901       };
67902     }
67903   }
67904
67905
67906 }
67907
67908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
67909   void * jresult ;
67910   Dali::Toolkit::Control *arg1 = 0 ;
67911   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
67912
67913   arg1 = (Dali::Toolkit::Control *)jarg1;
67914   if (!arg1) {
67915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67916     return 0;
67917   }
67918   {
67919     try {
67920       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
67921     } catch (std::out_of_range& e) {
67922       {
67923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67924       };
67925     } catch (std::exception& e) {
67926       {
67927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67928       };
67929     } catch (Dali::DaliException e) {
67930       {
67931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67932       };
67933     } catch (...) {
67934       {
67935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67936       };
67937     }
67938   }
67939
67940   jresult = (void *)result;
67941   return jresult;
67942 }
67943
67944
67945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
67946   unsigned int jresult ;
67947   Dali::Toolkit::Control *arg1 = 0 ;
67948   bool result;
67949
67950   arg1 = (Dali::Toolkit::Control *)jarg1;
67951   if (!arg1) {
67952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67953     return 0;
67954   }
67955   {
67956     try {
67957       result = (bool)arg1->IsResourceReady();
67958     } catch (std::out_of_range& e) {
67959       {
67960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67961       };
67962     } catch (std::exception& e) {
67963       {
67964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67965       };
67966     } catch (Dali::DaliException e) {
67967       {
67968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67969       };
67970     } catch (...) {
67971       {
67972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67973       };
67974     }
67975   }
67976
67977   jresult = result;
67978   return jresult;
67979 }
67980
67981
67982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
67983   void * jresult ;
67984   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
67985
67986   {
67987     try {
67988       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
67989     } catch (std::out_of_range& e) {
67990       {
67991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67992       };
67993     } catch (std::exception& e) {
67994       {
67995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67996       };
67997     } catch (Dali::DaliException e) {
67998       {
67999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68000       };
68001     } catch (...) {
68002       {
68003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68004       };
68005     }
68006   }
68007
68008   jresult = (void *)result;
68009   return jresult;
68010 }
68011
68012
68013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68014   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68015
68016   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68017   {
68018     try {
68019       delete arg1;
68020     } catch (std::out_of_range& e) {
68021       {
68022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68023       };
68024     } catch (std::exception& e) {
68025       {
68026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68027       };
68028     } catch (Dali::DaliException e) {
68029       {
68030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68031       };
68032     } catch (...) {
68033       {
68034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68035       };
68036     }
68037   }
68038
68039 }
68040
68041
68042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68043   void * jresult ;
68044   Dali::Toolkit::KeyInputFocusManager result;
68045
68046   {
68047     try {
68048       result = Dali::Toolkit::KeyInputFocusManager::Get();
68049     } catch (std::out_of_range& e) {
68050       {
68051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68052       };
68053     } catch (std::exception& e) {
68054       {
68055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68056       };
68057     } catch (Dali::DaliException e) {
68058       {
68059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68060       };
68061     } catch (...) {
68062       {
68063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68064       };
68065     }
68066   }
68067
68068   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68069   return jresult;
68070 }
68071
68072
68073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68074   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68075   Dali::Toolkit::Control arg2 ;
68076   Dali::Toolkit::Control *argp2 ;
68077
68078   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68079   argp2 = (Dali::Toolkit::Control *)jarg2;
68080   if (!argp2) {
68081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68082     return ;
68083   }
68084   arg2 = *argp2;
68085   {
68086     try {
68087       (arg1)->SetFocus(arg2);
68088     } catch (std::out_of_range& e) {
68089       {
68090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68091       };
68092     } catch (std::exception& e) {
68093       {
68094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68095       };
68096     } catch (Dali::DaliException e) {
68097       {
68098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68099       };
68100     } catch (...) {
68101       {
68102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68103       };
68104     }
68105   }
68106
68107 }
68108
68109
68110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68111   void * jresult ;
68112   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68113   Dali::Toolkit::Control result;
68114
68115   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68116   {
68117     try {
68118       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68119     } catch (std::out_of_range& e) {
68120       {
68121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68122       };
68123     } catch (std::exception& e) {
68124       {
68125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68126       };
68127     } catch (Dali::DaliException e) {
68128       {
68129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68130       };
68131     } catch (...) {
68132       {
68133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68134       };
68135     }
68136   }
68137
68138   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68139   return jresult;
68140 }
68141
68142
68143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68144   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68145   Dali::Toolkit::Control arg2 ;
68146   Dali::Toolkit::Control *argp2 ;
68147
68148   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68149   argp2 = (Dali::Toolkit::Control *)jarg2;
68150   if (!argp2) {
68151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68152     return ;
68153   }
68154   arg2 = *argp2;
68155   {
68156     try {
68157       (arg1)->RemoveFocus(arg2);
68158     } catch (std::out_of_range& e) {
68159       {
68160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68161       };
68162     } catch (std::exception& e) {
68163       {
68164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68165       };
68166     } catch (Dali::DaliException e) {
68167       {
68168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68169       };
68170     } catch (...) {
68171       {
68172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68173       };
68174     }
68175   }
68176
68177 }
68178
68179
68180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68181   void * jresult ;
68182   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68183   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68184
68185   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68186   {
68187     try {
68188       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68189     } catch (std::out_of_range& e) {
68190       {
68191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68192       };
68193     } catch (std::exception& e) {
68194       {
68195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68196       };
68197     } catch (Dali::DaliException e) {
68198       {
68199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68200       };
68201     } catch (...) {
68202       {
68203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68204       };
68205     }
68206   }
68207
68208   jresult = (void *)result;
68209   return jresult;
68210 }
68211
68212
68213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68214   void * jresult ;
68215   Dali::Toolkit::Alignment::Padding *result = 0 ;
68216
68217   {
68218     try {
68219       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68220     } catch (std::out_of_range& e) {
68221       {
68222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68223       };
68224     } catch (std::exception& e) {
68225       {
68226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68227       };
68228     } catch (Dali::DaliException e) {
68229       {
68230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68231       };
68232     } catch (...) {
68233       {
68234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68235       };
68236     }
68237   }
68238
68239   jresult = (void *)result;
68240   return jresult;
68241 }
68242
68243
68244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68245   void * jresult ;
68246   float arg1 ;
68247   float arg2 ;
68248   float arg3 ;
68249   float arg4 ;
68250   Dali::Toolkit::Alignment::Padding *result = 0 ;
68251
68252   arg1 = (float)jarg1;
68253   arg2 = (float)jarg2;
68254   arg3 = (float)jarg3;
68255   arg4 = (float)jarg4;
68256   {
68257     try {
68258       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68259     } catch (std::out_of_range& e) {
68260       {
68261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68262       };
68263     } catch (std::exception& e) {
68264       {
68265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68266       };
68267     } catch (Dali::DaliException e) {
68268       {
68269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68270       };
68271     } catch (...) {
68272       {
68273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68274       };
68275     }
68276   }
68277
68278   jresult = (void *)result;
68279   return jresult;
68280 }
68281
68282
68283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68284   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68285   float arg2 ;
68286
68287   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68288   arg2 = (float)jarg2;
68289   if (arg1) (arg1)->left = arg2;
68290 }
68291
68292
68293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68294   float jresult ;
68295   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68296   float result;
68297
68298   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68299   result = (float) ((arg1)->left);
68300   jresult = result;
68301   return jresult;
68302 }
68303
68304
68305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68306   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68307   float arg2 ;
68308
68309   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68310   arg2 = (float)jarg2;
68311   if (arg1) (arg1)->right = arg2;
68312 }
68313
68314
68315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68316   float jresult ;
68317   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68318   float result;
68319
68320   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68321   result = (float) ((arg1)->right);
68322   jresult = result;
68323   return jresult;
68324 }
68325
68326
68327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68328   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68329   float arg2 ;
68330
68331   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68332   arg2 = (float)jarg2;
68333   if (arg1) (arg1)->top = arg2;
68334 }
68335
68336
68337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68338   float jresult ;
68339   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68340   float result;
68341
68342   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68343   result = (float) ((arg1)->top);
68344   jresult = result;
68345   return jresult;
68346 }
68347
68348
68349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68350   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68351   float arg2 ;
68352
68353   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68354   arg2 = (float)jarg2;
68355   if (arg1) (arg1)->bottom = arg2;
68356 }
68357
68358
68359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68360   float jresult ;
68361   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68362   float result;
68363
68364   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68365   result = (float) ((arg1)->bottom);
68366   jresult = result;
68367   return jresult;
68368 }
68369
68370
68371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68372   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68373
68374   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68375   {
68376     try {
68377       delete arg1;
68378     } catch (std::out_of_range& e) {
68379       {
68380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68381       };
68382     } catch (std::exception& e) {
68383       {
68384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68385       };
68386     } catch (Dali::DaliException e) {
68387       {
68388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68389       };
68390     } catch (...) {
68391       {
68392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68393       };
68394     }
68395   }
68396
68397 }
68398
68399
68400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68401   void * jresult ;
68402   Dali::Toolkit::Alignment *result = 0 ;
68403
68404   {
68405     try {
68406       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68407     } catch (std::out_of_range& e) {
68408       {
68409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68410       };
68411     } catch (std::exception& e) {
68412       {
68413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68414       };
68415     } catch (Dali::DaliException e) {
68416       {
68417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68418       };
68419     } catch (...) {
68420       {
68421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68422       };
68423     }
68424   }
68425
68426   jresult = (void *)result;
68427   return jresult;
68428 }
68429
68430
68431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68432   void * jresult ;
68433   Dali::Toolkit::Alignment::Type arg1 ;
68434   Dali::Toolkit::Alignment::Type arg2 ;
68435   Dali::Toolkit::Alignment result;
68436
68437   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68438   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68439   {
68440     try {
68441       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68442     } catch (std::out_of_range& e) {
68443       {
68444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68445       };
68446     } catch (std::exception& e) {
68447       {
68448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68449       };
68450     } catch (Dali::DaliException e) {
68451       {
68452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68453       };
68454     } catch (...) {
68455       {
68456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68457       };
68458     }
68459   }
68460
68461   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68462   return jresult;
68463 }
68464
68465
68466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68467   void * jresult ;
68468   Dali::Toolkit::Alignment::Type arg1 ;
68469   Dali::Toolkit::Alignment result;
68470
68471   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68472   {
68473     try {
68474       result = Dali::Toolkit::Alignment::New(arg1);
68475     } catch (std::out_of_range& e) {
68476       {
68477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68478       };
68479     } catch (std::exception& e) {
68480       {
68481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68482       };
68483     } catch (Dali::DaliException e) {
68484       {
68485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68486       };
68487     } catch (...) {
68488       {
68489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68490       };
68491     }
68492   }
68493
68494   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68495   return jresult;
68496 }
68497
68498
68499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68500   void * jresult ;
68501   Dali::Toolkit::Alignment result;
68502
68503   {
68504     try {
68505       result = Dali::Toolkit::Alignment::New();
68506     } catch (std::out_of_range& e) {
68507       {
68508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68509       };
68510     } catch (std::exception& e) {
68511       {
68512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68513       };
68514     } catch (Dali::DaliException e) {
68515       {
68516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68517       };
68518     } catch (...) {
68519       {
68520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68521       };
68522     }
68523   }
68524
68525   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68526   return jresult;
68527 }
68528
68529
68530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68531   void * jresult ;
68532   Dali::Toolkit::Alignment *arg1 = 0 ;
68533   Dali::Toolkit::Alignment *result = 0 ;
68534
68535   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68536   if (!arg1) {
68537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68538     return 0;
68539   }
68540   {
68541     try {
68542       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68543     } catch (std::out_of_range& e) {
68544       {
68545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68546       };
68547     } catch (std::exception& e) {
68548       {
68549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68550       };
68551     } catch (Dali::DaliException e) {
68552       {
68553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68554       };
68555     } catch (...) {
68556       {
68557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68558       };
68559     }
68560   }
68561
68562   jresult = (void *)result;
68563   return jresult;
68564 }
68565
68566
68567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68568   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68569
68570   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68571   {
68572     try {
68573       delete arg1;
68574     } catch (std::out_of_range& e) {
68575       {
68576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68577       };
68578     } catch (std::exception& e) {
68579       {
68580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68581       };
68582     } catch (Dali::DaliException e) {
68583       {
68584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68585       };
68586     } catch (...) {
68587       {
68588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68589       };
68590     }
68591   }
68592
68593 }
68594
68595
68596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68597   void * jresult ;
68598   Dali::BaseHandle arg1 ;
68599   Dali::BaseHandle *argp1 ;
68600   Dali::Toolkit::Alignment result;
68601
68602   argp1 = (Dali::BaseHandle *)jarg1;
68603   if (!argp1) {
68604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68605     return 0;
68606   }
68607   arg1 = *argp1;
68608   {
68609     try {
68610       result = Dali::Toolkit::Alignment::DownCast(arg1);
68611     } catch (std::out_of_range& e) {
68612       {
68613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68614       };
68615     } catch (std::exception& e) {
68616       {
68617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68618       };
68619     } catch (Dali::DaliException e) {
68620       {
68621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68622       };
68623     } catch (...) {
68624       {
68625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68626       };
68627     }
68628   }
68629
68630   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68631   return jresult;
68632 }
68633
68634
68635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68636   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68637   Dali::Toolkit::Alignment::Type arg2 ;
68638
68639   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68640   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68641   {
68642     try {
68643       (arg1)->SetAlignmentType(arg2);
68644     } catch (std::out_of_range& e) {
68645       {
68646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68647       };
68648     } catch (std::exception& e) {
68649       {
68650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68651       };
68652     } catch (Dali::DaliException e) {
68653       {
68654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68655       };
68656     } catch (...) {
68657       {
68658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68659       };
68660     }
68661   }
68662
68663 }
68664
68665
68666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68667   int jresult ;
68668   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68669   Dali::Toolkit::Alignment::Type result;
68670
68671   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68672   {
68673     try {
68674       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
68675     } catch (std::out_of_range& e) {
68676       {
68677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68678       };
68679     } catch (std::exception& e) {
68680       {
68681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68682       };
68683     } catch (Dali::DaliException e) {
68684       {
68685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68686       };
68687     } catch (...) {
68688       {
68689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68690       };
68691     }
68692   }
68693
68694   jresult = (int)result;
68695   return jresult;
68696 }
68697
68698
68699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
68700   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68701   Dali::Toolkit::Alignment::Scaling arg2 ;
68702
68703   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68704   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
68705   {
68706     try {
68707       (arg1)->SetScaling(arg2);
68708     } catch (std::out_of_range& e) {
68709       {
68710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68711       };
68712     } catch (std::exception& e) {
68713       {
68714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68715       };
68716     } catch (Dali::DaliException e) {
68717       {
68718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68719       };
68720     } catch (...) {
68721       {
68722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68723       };
68724     }
68725   }
68726
68727 }
68728
68729
68730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
68731   int jresult ;
68732   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68733   Dali::Toolkit::Alignment::Scaling result;
68734
68735   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68736   {
68737     try {
68738       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
68739     } catch (std::out_of_range& e) {
68740       {
68741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68742       };
68743     } catch (std::exception& e) {
68744       {
68745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68746       };
68747     } catch (Dali::DaliException e) {
68748       {
68749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68750       };
68751     } catch (...) {
68752       {
68753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68754       };
68755     }
68756   }
68757
68758   jresult = (int)result;
68759   return jresult;
68760 }
68761
68762
68763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
68764   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68765   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
68766
68767   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68768   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
68769   if (!arg2) {
68770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
68771     return ;
68772   }
68773   {
68774     try {
68775       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
68776     } catch (std::out_of_range& e) {
68777       {
68778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68779       };
68780     } catch (std::exception& e) {
68781       {
68782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68783       };
68784     } catch (Dali::DaliException e) {
68785       {
68786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68787       };
68788     } catch (...) {
68789       {
68790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68791       };
68792     }
68793   }
68794
68795 }
68796
68797
68798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
68799   void * jresult ;
68800   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68801   Dali::Toolkit::Alignment::Padding *result = 0 ;
68802
68803   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68804   {
68805     try {
68806       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
68807     } catch (std::out_of_range& e) {
68808       {
68809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68810       };
68811     } catch (std::exception& e) {
68812       {
68813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68814       };
68815     } catch (Dali::DaliException e) {
68816       {
68817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68818       };
68819     } catch (...) {
68820       {
68821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68822       };
68823     }
68824   }
68825
68826   jresult = (void *)result;
68827   return jresult;
68828 }
68829
68830
68831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
68832   void * jresult ;
68833   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68834   Dali::Toolkit::Alignment *arg2 = 0 ;
68835   Dali::Toolkit::Alignment *result = 0 ;
68836
68837   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68838   arg2 = (Dali::Toolkit::Alignment *)jarg2;
68839   if (!arg2) {
68840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68841     return 0;
68842   }
68843   {
68844     try {
68845       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
68846     } catch (std::out_of_range& e) {
68847       {
68848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68849       };
68850     } catch (std::exception& e) {
68851       {
68852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68853       };
68854     } catch (Dali::DaliException e) {
68855       {
68856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68857       };
68858     } catch (...) {
68859       {
68860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68861       };
68862     }
68863   }
68864
68865   jresult = (void *)result;
68866   return jresult;
68867 }
68868
68869
68870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
68871   int jresult ;
68872   int result;
68873
68874   result = (int)Dali::Toolkit::Button::Property::DISABLED;
68875   jresult = (int)result;
68876   return jresult;
68877 }
68878
68879
68880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
68881   int jresult ;
68882   int result;
68883
68884   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
68885   jresult = (int)result;
68886   return jresult;
68887 }
68888
68889
68890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
68891   int jresult ;
68892   int result;
68893
68894   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
68895   jresult = (int)result;
68896   return jresult;
68897 }
68898
68899
68900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
68901   int jresult ;
68902   int result;
68903
68904   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
68905   jresult = (int)result;
68906   return jresult;
68907 }
68908
68909
68910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
68911   int jresult ;
68912   int result;
68913
68914   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
68915   jresult = (int)result;
68916   return jresult;
68917 }
68918
68919
68920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
68921   int jresult ;
68922   int result;
68923
68924   result = (int)Dali::Toolkit::Button::Property::SELECTED;
68925   jresult = (int)result;
68926   return jresult;
68927 }
68928
68929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
68930   int jresult ;
68931   int result;
68932
68933   result = (int)Dali::Toolkit::Button::Property::LABEL;
68934   jresult = (int)result;
68935   return jresult;
68936 }
68937
68938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
68939   void * jresult ;
68940   Dali::Toolkit::Button::Property *result = 0 ;
68941
68942   {
68943     try {
68944       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
68945     } catch (std::out_of_range& e) {
68946       {
68947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68948       };
68949     } catch (std::exception& e) {
68950       {
68951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68952       };
68953     } catch (Dali::DaliException e) {
68954       {
68955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68956       };
68957     } catch (...) {
68958       {
68959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68960       };
68961     }
68962   }
68963
68964   jresult = (void *)result;
68965   return jresult;
68966 }
68967
68968
68969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
68970   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
68971
68972   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
68973   {
68974     try {
68975       delete arg1;
68976     } catch (std::out_of_range& e) {
68977       {
68978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68979       };
68980     } catch (std::exception& e) {
68981       {
68982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68983       };
68984     } catch (Dali::DaliException e) {
68985       {
68986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68987       };
68988     } catch (...) {
68989       {
68990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68991       };
68992     }
68993   }
68994
68995 }
68996
68997
68998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
68999   void * jresult ;
69000   Dali::Toolkit::Button *result = 0 ;
69001
69002   {
69003     try {
69004       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69005     } catch (std::out_of_range& e) {
69006       {
69007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69008       };
69009     } catch (std::exception& e) {
69010       {
69011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69012       };
69013     } catch (Dali::DaliException e) {
69014       {
69015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69016       };
69017     } catch (...) {
69018       {
69019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69020       };
69021     }
69022   }
69023
69024   jresult = (void *)result;
69025   return jresult;
69026 }
69027
69028
69029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69030   void * jresult ;
69031   Dali::Toolkit::Button *arg1 = 0 ;
69032   Dali::Toolkit::Button *result = 0 ;
69033
69034   arg1 = (Dali::Toolkit::Button *)jarg1;
69035   if (!arg1) {
69036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69037     return 0;
69038   }
69039   {
69040     try {
69041       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69042     } catch (std::out_of_range& e) {
69043       {
69044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69045       };
69046     } catch (std::exception& e) {
69047       {
69048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69049       };
69050     } catch (Dali::DaliException e) {
69051       {
69052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69053       };
69054     } catch (...) {
69055       {
69056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69057       };
69058     }
69059   }
69060
69061   jresult = (void *)result;
69062   return jresult;
69063 }
69064
69065
69066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69067   void * jresult ;
69068   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69069   Dali::Toolkit::Button *arg2 = 0 ;
69070   Dali::Toolkit::Button *result = 0 ;
69071
69072   arg1 = (Dali::Toolkit::Button *)jarg1;
69073   arg2 = (Dali::Toolkit::Button *)jarg2;
69074   if (!arg2) {
69075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69076     return 0;
69077   }
69078   {
69079     try {
69080       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69081     } catch (std::out_of_range& e) {
69082       {
69083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69084       };
69085     } catch (std::exception& e) {
69086       {
69087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69088       };
69089     } catch (Dali::DaliException e) {
69090       {
69091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69092       };
69093     } catch (...) {
69094       {
69095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69096       };
69097     }
69098   }
69099
69100   jresult = (void *)result;
69101   return jresult;
69102 }
69103
69104
69105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69106   void * jresult ;
69107   Dali::BaseHandle arg1 ;
69108   Dali::BaseHandle *argp1 ;
69109   Dali::Toolkit::Button result;
69110
69111   argp1 = (Dali::BaseHandle *)jarg1;
69112   if (!argp1) {
69113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69114     return 0;
69115   }
69116   arg1 = *argp1;
69117   {
69118     try {
69119       result = Dali::Toolkit::Button::DownCast(arg1);
69120     } catch (std::out_of_range& e) {
69121       {
69122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69123       };
69124     } catch (std::exception& e) {
69125       {
69126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69127       };
69128     } catch (Dali::DaliException e) {
69129       {
69130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69131       };
69132     } catch (...) {
69133       {
69134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69135       };
69136     }
69137   }
69138
69139   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69140   return jresult;
69141 }
69142
69143
69144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69145   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69146
69147   arg1 = (Dali::Toolkit::Button *)jarg1;
69148   {
69149     try {
69150       delete arg1;
69151     } catch (std::out_of_range& e) {
69152       {
69153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69154       };
69155     } catch (std::exception& e) {
69156       {
69157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69158       };
69159     } catch (Dali::DaliException e) {
69160       {
69161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69162       };
69163     } catch (...) {
69164       {
69165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69166       };
69167     }
69168   }
69169
69170 }
69171
69172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69173   void * jresult ;
69174   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69175   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69176
69177   arg1 = (Dali::Toolkit::Button *)jarg1;
69178   {
69179     try {
69180       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69181     } catch (std::out_of_range& e) {
69182       {
69183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69184       };
69185     } catch (std::exception& e) {
69186       {
69187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69188       };
69189     } catch (Dali::DaliException e) {
69190       {
69191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69192       };
69193     } catch (...) {
69194       {
69195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69196       };
69197     }
69198   }
69199
69200   jresult = (void *)result;
69201   return jresult;
69202 }
69203
69204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
69205   void * jresult ;
69206   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69207   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69208
69209   arg1 = (Dali::Toolkit::Button *)jarg1;
69210   {
69211     try {
69212       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
69213     } catch (std::out_of_range& e) {
69214       {
69215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69216       };
69217     } catch (std::exception& e) {
69218       {
69219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69220       };
69221     } catch (Dali::DaliException e) {
69222       {
69223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69224       };
69225     } catch (...) {
69226       {
69227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69228       };
69229     }
69230   }
69231
69232   jresult = (void *)result;
69233   return jresult;
69234 }
69235
69236
69237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
69238   void * jresult ;
69239   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69240   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69241
69242   arg1 = (Dali::Toolkit::Button *)jarg1;
69243   {
69244     try {
69245       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
69246     } catch (std::out_of_range& e) {
69247       {
69248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69249       };
69250     } catch (std::exception& e) {
69251       {
69252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69253       };
69254     } catch (Dali::DaliException e) {
69255       {
69256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69257       };
69258     } catch (...) {
69259       {
69260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69261       };
69262     }
69263   }
69264
69265   jresult = (void *)result;
69266   return jresult;
69267 }
69268
69269
69270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
69271   void * jresult ;
69272   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69273   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69274
69275   arg1 = (Dali::Toolkit::Button *)jarg1;
69276   {
69277     try {
69278       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
69279     } catch (std::out_of_range& e) {
69280       {
69281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69282       };
69283     } catch (std::exception& e) {
69284       {
69285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69286       };
69287     } catch (Dali::DaliException e) {
69288       {
69289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69290       };
69291     } catch (...) {
69292       {
69293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69294       };
69295     }
69296   }
69297
69298   jresult = (void *)result;
69299   return jresult;
69300 }
69301
69302
69303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
69304   void * jresult ;
69305   Dali::Toolkit::CheckBoxButton *result = 0 ;
69306
69307   {
69308     try {
69309       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
69310     } catch (std::out_of_range& e) {
69311       {
69312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69313       };
69314     } catch (std::exception& e) {
69315       {
69316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69317       };
69318     } catch (Dali::DaliException e) {
69319       {
69320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69321       };
69322     } catch (...) {
69323       {
69324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69325       };
69326     }
69327   }
69328
69329   jresult = (void *)result;
69330   return jresult;
69331 }
69332
69333
69334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
69335   void * jresult ;
69336   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
69337   Dali::Toolkit::CheckBoxButton *result = 0 ;
69338
69339   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69340   if (!arg1) {
69341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69342     return 0;
69343   }
69344   {
69345     try {
69346       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
69347     } catch (std::out_of_range& e) {
69348       {
69349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69350       };
69351     } catch (std::exception& e) {
69352       {
69353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69354       };
69355     } catch (Dali::DaliException e) {
69356       {
69357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69358       };
69359     } catch (...) {
69360       {
69361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69362       };
69363     }
69364   }
69365
69366   jresult = (void *)result;
69367   return jresult;
69368 }
69369
69370
69371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
69372   void * jresult ;
69373   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69374   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
69375   Dali::Toolkit::CheckBoxButton *result = 0 ;
69376
69377   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69378   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
69379   if (!arg2) {
69380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69381     return 0;
69382   }
69383   {
69384     try {
69385       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
69386     } catch (std::out_of_range& e) {
69387       {
69388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69389       };
69390     } catch (std::exception& e) {
69391       {
69392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69393       };
69394     } catch (Dali::DaliException e) {
69395       {
69396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69397       };
69398     } catch (...) {
69399       {
69400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69401       };
69402     }
69403   }
69404
69405   jresult = (void *)result;
69406   return jresult;
69407 }
69408
69409
69410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
69411   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69412
69413   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69414   {
69415     try {
69416       delete arg1;
69417     } catch (std::out_of_range& e) {
69418       {
69419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69420       };
69421     } catch (std::exception& e) {
69422       {
69423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69424       };
69425     } catch (Dali::DaliException e) {
69426       {
69427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69428       };
69429     } catch (...) {
69430       {
69431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69432       };
69433     }
69434   }
69435
69436 }
69437
69438
69439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
69440   void * jresult ;
69441   Dali::Toolkit::CheckBoxButton result;
69442
69443   {
69444     try {
69445       result = Dali::Toolkit::CheckBoxButton::New();
69446     } catch (std::out_of_range& e) {
69447       {
69448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69449       };
69450     } catch (std::exception& e) {
69451       {
69452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69453       };
69454     } catch (Dali::DaliException e) {
69455       {
69456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69457       };
69458     } catch (...) {
69459       {
69460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69461       };
69462     }
69463   }
69464
69465   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69466   return jresult;
69467 }
69468
69469
69470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
69471   void * jresult ;
69472   Dali::BaseHandle arg1 ;
69473   Dali::BaseHandle *argp1 ;
69474   Dali::Toolkit::CheckBoxButton result;
69475
69476   argp1 = (Dali::BaseHandle *)jarg1;
69477   if (!argp1) {
69478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69479     return 0;
69480   }
69481   arg1 = *argp1;
69482   {
69483     try {
69484       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
69485     } catch (std::out_of_range& e) {
69486       {
69487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69488       };
69489     } catch (std::exception& e) {
69490       {
69491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69492       };
69493     } catch (Dali::DaliException e) {
69494       {
69495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69496       };
69497     } catch (...) {
69498       {
69499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69500       };
69501     }
69502   }
69503
69504   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69505   return jresult;
69506 }
69507
69508
69509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
69510   int jresult ;
69511   int result;
69512
69513   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
69514   jresult = (int)result;
69515   return jresult;
69516 }
69517
69518
69519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
69520   int jresult ;
69521   int result;
69522
69523   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
69524   jresult = (int)result;
69525   return jresult;
69526 }
69527
69528
69529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
69530   int jresult ;
69531   int result;
69532
69533   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
69534   jresult = (int)result;
69535   return jresult;
69536 }
69537
69538
69539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
69540   int jresult ;
69541   int result;
69542
69543   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
69544   jresult = (int)result;
69545   return jresult;
69546 }
69547
69548
69549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
69550   int jresult ;
69551   int result;
69552
69553   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
69554   jresult = (int)result;
69555   return jresult;
69556 }
69557
69558
69559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
69560   void * jresult ;
69561   Dali::Toolkit::PushButton::Property *result = 0 ;
69562
69563   {
69564     try {
69565       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
69566     } catch (std::out_of_range& e) {
69567       {
69568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69569       };
69570     } catch (std::exception& e) {
69571       {
69572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69573       };
69574     } catch (Dali::DaliException e) {
69575       {
69576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69577       };
69578     } catch (...) {
69579       {
69580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69581       };
69582     }
69583   }
69584
69585   jresult = (void *)result;
69586   return jresult;
69587 }
69588
69589
69590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
69591   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
69592
69593   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
69594   {
69595     try {
69596       delete arg1;
69597     } catch (std::out_of_range& e) {
69598       {
69599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69600       };
69601     } catch (std::exception& e) {
69602       {
69603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69604       };
69605     } catch (Dali::DaliException e) {
69606       {
69607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69608       };
69609     } catch (...) {
69610       {
69611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69612       };
69613     }
69614   }
69615
69616 }
69617
69618
69619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
69620   void * jresult ;
69621   Dali::Toolkit::PushButton *result = 0 ;
69622
69623   {
69624     try {
69625       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
69626     } catch (std::out_of_range& e) {
69627       {
69628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69629       };
69630     } catch (std::exception& e) {
69631       {
69632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69633       };
69634     } catch (Dali::DaliException e) {
69635       {
69636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69637       };
69638     } catch (...) {
69639       {
69640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69641       };
69642     }
69643   }
69644
69645   jresult = (void *)result;
69646   return jresult;
69647 }
69648
69649
69650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
69651   void * jresult ;
69652   Dali::Toolkit::PushButton *arg1 = 0 ;
69653   Dali::Toolkit::PushButton *result = 0 ;
69654
69655   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69656   if (!arg1) {
69657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69658     return 0;
69659   }
69660   {
69661     try {
69662       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
69663     } catch (std::out_of_range& e) {
69664       {
69665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69666       };
69667     } catch (std::exception& e) {
69668       {
69669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69670       };
69671     } catch (Dali::DaliException e) {
69672       {
69673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69674       };
69675     } catch (...) {
69676       {
69677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69678       };
69679     }
69680   }
69681
69682   jresult = (void *)result;
69683   return jresult;
69684 }
69685
69686
69687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
69688   void * jresult ;
69689   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69690   Dali::Toolkit::PushButton *arg2 = 0 ;
69691   Dali::Toolkit::PushButton *result = 0 ;
69692
69693   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69694   arg2 = (Dali::Toolkit::PushButton *)jarg2;
69695   if (!arg2) {
69696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69697     return 0;
69698   }
69699   {
69700     try {
69701       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
69702     } catch (std::out_of_range& e) {
69703       {
69704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69705       };
69706     } catch (std::exception& e) {
69707       {
69708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69709       };
69710     } catch (Dali::DaliException e) {
69711       {
69712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69713       };
69714     } catch (...) {
69715       {
69716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69717       };
69718     }
69719   }
69720
69721   jresult = (void *)result;
69722   return jresult;
69723 }
69724
69725
69726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
69727   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69728
69729   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69730   {
69731     try {
69732       delete arg1;
69733     } catch (std::out_of_range& e) {
69734       {
69735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69736       };
69737     } catch (std::exception& e) {
69738       {
69739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69740       };
69741     } catch (Dali::DaliException e) {
69742       {
69743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69744       };
69745     } catch (...) {
69746       {
69747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69748       };
69749     }
69750   }
69751
69752 }
69753
69754
69755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
69756   void * jresult ;
69757   Dali::Toolkit::PushButton result;
69758
69759   {
69760     try {
69761       result = Dali::Toolkit::PushButton::New();
69762     } catch (std::out_of_range& e) {
69763       {
69764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69765       };
69766     } catch (std::exception& e) {
69767       {
69768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69769       };
69770     } catch (Dali::DaliException e) {
69771       {
69772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69773       };
69774     } catch (...) {
69775       {
69776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69777       };
69778     }
69779   }
69780
69781   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69782   return jresult;
69783 }
69784
69785
69786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
69787   void * jresult ;
69788   Dali::BaseHandle arg1 ;
69789   Dali::BaseHandle *argp1 ;
69790   Dali::Toolkit::PushButton result;
69791
69792   argp1 = (Dali::BaseHandle *)jarg1;
69793   if (!argp1) {
69794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69795     return 0;
69796   }
69797   arg1 = *argp1;
69798   {
69799     try {
69800       result = Dali::Toolkit::PushButton::DownCast(arg1);
69801     } catch (std::out_of_range& e) {
69802       {
69803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69804       };
69805     } catch (std::exception& e) {
69806       {
69807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69808       };
69809     } catch (Dali::DaliException e) {
69810       {
69811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69812       };
69813     } catch (...) {
69814       {
69815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69816       };
69817     }
69818   }
69819
69820   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69821   return jresult;
69822 }
69823
69824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
69825   void * jresult ;
69826   Dali::Toolkit::RadioButton *result = 0 ;
69827
69828   {
69829     try {
69830       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
69831     } catch (std::out_of_range& e) {
69832       {
69833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69834       };
69835     } catch (std::exception& e) {
69836       {
69837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69838       };
69839     } catch (Dali::DaliException e) {
69840       {
69841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69842       };
69843     } catch (...) {
69844       {
69845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69846       };
69847     }
69848   }
69849
69850   jresult = (void *)result;
69851   return jresult;
69852 }
69853
69854
69855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
69856   void * jresult ;
69857   Dali::Toolkit::RadioButton *arg1 = 0 ;
69858   Dali::Toolkit::RadioButton *result = 0 ;
69859
69860   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69861   if (!arg1) {
69862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69863     return 0;
69864   }
69865   {
69866     try {
69867       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
69868     } catch (std::out_of_range& e) {
69869       {
69870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69871       };
69872     } catch (std::exception& e) {
69873       {
69874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69875       };
69876     } catch (Dali::DaliException e) {
69877       {
69878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69879       };
69880     } catch (...) {
69881       {
69882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69883       };
69884     }
69885   }
69886
69887   jresult = (void *)result;
69888   return jresult;
69889 }
69890
69891
69892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
69893   void * jresult ;
69894   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
69895   Dali::Toolkit::RadioButton *arg2 = 0 ;
69896   Dali::Toolkit::RadioButton *result = 0 ;
69897
69898   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69899   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
69900   if (!arg2) {
69901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69902     return 0;
69903   }
69904   {
69905     try {
69906       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
69907     } catch (std::out_of_range& e) {
69908       {
69909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69910       };
69911     } catch (std::exception& e) {
69912       {
69913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69914       };
69915     } catch (Dali::DaliException e) {
69916       {
69917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69918       };
69919     } catch (...) {
69920       {
69921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69922       };
69923     }
69924   }
69925
69926   jresult = (void *)result;
69927   return jresult;
69928 }
69929
69930
69931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
69932   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
69933
69934   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69935   {
69936     try {
69937       delete arg1;
69938     } catch (std::out_of_range& e) {
69939       {
69940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69941       };
69942     } catch (std::exception& e) {
69943       {
69944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69945       };
69946     } catch (Dali::DaliException e) {
69947       {
69948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69949       };
69950     } catch (...) {
69951       {
69952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69953       };
69954     }
69955   }
69956
69957 }
69958
69959
69960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
69961   void * jresult ;
69962   Dali::Toolkit::RadioButton result;
69963
69964   {
69965     try {
69966       result = Dali::Toolkit::RadioButton::New();
69967     } catch (std::out_of_range& e) {
69968       {
69969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69970       };
69971     } catch (std::exception& e) {
69972       {
69973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69974       };
69975     } catch (Dali::DaliException e) {
69976       {
69977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69978       };
69979     } catch (...) {
69980       {
69981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69982       };
69983     }
69984   }
69985
69986   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
69987   return jresult;
69988 }
69989
69990
69991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
69992   void * jresult ;
69993   std::string *arg1 = 0 ;
69994   Dali::Toolkit::RadioButton result;
69995
69996   if (!jarg1) {
69997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
69998     return 0;
69999   }
70000   std::string arg1_str(jarg1);
70001   arg1 = &arg1_str;
70002   {
70003     try {
70004       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
70005     } catch (std::out_of_range& e) {
70006       {
70007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70008       };
70009     } catch (std::exception& e) {
70010       {
70011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70012       };
70013     } catch (Dali::DaliException e) {
70014       {
70015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70016       };
70017     } catch (...) {
70018       {
70019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70020       };
70021     }
70022   }
70023
70024   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70025
70026   //argout typemap for const std::string&
70027
70028   return jresult;
70029 }
70030
70031
70032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
70033   void * jresult ;
70034   Dali::BaseHandle arg1 ;
70035   Dali::BaseHandle *argp1 ;
70036   Dali::Toolkit::RadioButton result;
70037
70038   argp1 = (Dali::BaseHandle *)jarg1;
70039   if (!argp1) {
70040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70041     return 0;
70042   }
70043   arg1 = *argp1;
70044   {
70045     try {
70046       result = Dali::Toolkit::RadioButton::DownCast(arg1);
70047     } catch (std::out_of_range& e) {
70048       {
70049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70050       };
70051     } catch (std::exception& e) {
70052       {
70053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70054       };
70055     } catch (Dali::DaliException e) {
70056       {
70057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70058       };
70059     } catch (...) {
70060       {
70061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70062       };
70063     }
70064   }
70065
70066   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70067   return jresult;
70068 }
70069
70070
70071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
70072   int jresult ;
70073   int result;
70074
70075   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
70076   jresult = (int)result;
70077   return jresult;
70078 }
70079
70080
70081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
70082   int jresult ;
70083   int result;
70084
70085   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
70086   jresult = (int)result;
70087   return jresult;
70088 }
70089
70090
70091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
70092   int jresult ;
70093   int result;
70094
70095   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
70096   jresult = (int)result;
70097   return jresult;
70098 }
70099
70100
70101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
70102   int jresult ;
70103   int result;
70104
70105   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
70106   jresult = (int)result;
70107   return jresult;
70108 }
70109
70110
70111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
70112   int jresult ;
70113   int result;
70114
70115   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
70116   jresult = (int)result;
70117   return jresult;
70118 }
70119
70120
70121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
70122   int jresult ;
70123   int result;
70124
70125   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
70126   jresult = (int)result;
70127   return jresult;
70128 }
70129
70130
70131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
70132   void * jresult ;
70133   Dali::Toolkit::FlexContainer::Property *result = 0 ;
70134
70135   {
70136     try {
70137       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
70138     } catch (std::out_of_range& e) {
70139       {
70140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70141       };
70142     } catch (std::exception& e) {
70143       {
70144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70145       };
70146     } catch (Dali::DaliException e) {
70147       {
70148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70149       };
70150     } catch (...) {
70151       {
70152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70153       };
70154     }
70155   }
70156
70157   jresult = (void *)result;
70158   return jresult;
70159 }
70160
70161
70162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
70163   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
70164
70165   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
70166   {
70167     try {
70168       delete arg1;
70169     } catch (std::out_of_range& e) {
70170       {
70171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70172       };
70173     } catch (std::exception& e) {
70174       {
70175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70176       };
70177     } catch (Dali::DaliException e) {
70178       {
70179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70180       };
70181     } catch (...) {
70182       {
70183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70184       };
70185     }
70186   }
70187
70188 }
70189
70190
70191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
70192   int jresult ;
70193   int result;
70194
70195   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
70196   jresult = (int)result;
70197   return jresult;
70198 }
70199
70200
70201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
70202   int jresult ;
70203   int result;
70204
70205   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
70206   jresult = (int)result;
70207   return jresult;
70208 }
70209
70210
70211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
70212   int jresult ;
70213   int result;
70214
70215   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
70216   jresult = (int)result;
70217   return jresult;
70218 }
70219
70220
70221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
70222   void * jresult ;
70223   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
70224
70225   {
70226     try {
70227       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
70228     } catch (std::out_of_range& e) {
70229       {
70230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70231       };
70232     } catch (std::exception& e) {
70233       {
70234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70235       };
70236     } catch (Dali::DaliException e) {
70237       {
70238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70239       };
70240     } catch (...) {
70241       {
70242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70243       };
70244     }
70245   }
70246
70247   jresult = (void *)result;
70248   return jresult;
70249 }
70250
70251
70252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
70253   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
70254
70255   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
70256   {
70257     try {
70258       delete arg1;
70259     } catch (std::out_of_range& e) {
70260       {
70261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70262       };
70263     } catch (std::exception& e) {
70264       {
70265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70266       };
70267     } catch (Dali::DaliException e) {
70268       {
70269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70270       };
70271     } catch (...) {
70272       {
70273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70274       };
70275     }
70276   }
70277
70278 }
70279
70280
70281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
70282   void * jresult ;
70283   Dali::Toolkit::FlexContainer *result = 0 ;
70284
70285   {
70286     try {
70287       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
70288     } catch (std::out_of_range& e) {
70289       {
70290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70291       };
70292     } catch (std::exception& e) {
70293       {
70294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70295       };
70296     } catch (Dali::DaliException e) {
70297       {
70298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70299       };
70300     } catch (...) {
70301       {
70302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70303       };
70304     }
70305   }
70306
70307   jresult = (void *)result;
70308   return jresult;
70309 }
70310
70311
70312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
70313   void * jresult ;
70314   Dali::Toolkit::FlexContainer *arg1 = 0 ;
70315   Dali::Toolkit::FlexContainer *result = 0 ;
70316
70317   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70318   if (!arg1) {
70319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70320     return 0;
70321   }
70322   {
70323     try {
70324       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
70325     } catch (std::out_of_range& e) {
70326       {
70327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70328       };
70329     } catch (std::exception& e) {
70330       {
70331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70332       };
70333     } catch (Dali::DaliException e) {
70334       {
70335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70336       };
70337     } catch (...) {
70338       {
70339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70340       };
70341     }
70342   }
70343
70344   jresult = (void *)result;
70345   return jresult;
70346 }
70347
70348
70349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
70350   void * jresult ;
70351   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70352   Dali::Toolkit::FlexContainer *arg2 = 0 ;
70353   Dali::Toolkit::FlexContainer *result = 0 ;
70354
70355   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70356   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
70357   if (!arg2) {
70358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70359     return 0;
70360   }
70361   {
70362     try {
70363       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
70364     } catch (std::out_of_range& e) {
70365       {
70366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70367       };
70368     } catch (std::exception& e) {
70369       {
70370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70371       };
70372     } catch (Dali::DaliException e) {
70373       {
70374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70375       };
70376     } catch (...) {
70377       {
70378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70379       };
70380     }
70381   }
70382
70383   jresult = (void *)result;
70384   return jresult;
70385 }
70386
70387
70388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
70389   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70390
70391   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70392   {
70393     try {
70394       delete arg1;
70395     } catch (std::out_of_range& e) {
70396       {
70397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70398       };
70399     } catch (std::exception& e) {
70400       {
70401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70402       };
70403     } catch (Dali::DaliException e) {
70404       {
70405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70406       };
70407     } catch (...) {
70408       {
70409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70410       };
70411     }
70412   }
70413
70414 }
70415
70416
70417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
70418   void * jresult ;
70419   Dali::Toolkit::FlexContainer result;
70420
70421   {
70422     try {
70423       result = Dali::Toolkit::FlexContainer::New();
70424     } catch (std::out_of_range& e) {
70425       {
70426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70427       };
70428     } catch (std::exception& e) {
70429       {
70430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70431       };
70432     } catch (Dali::DaliException e) {
70433       {
70434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70435       };
70436     } catch (...) {
70437       {
70438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70439       };
70440     }
70441   }
70442
70443   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70444   return jresult;
70445 }
70446
70447
70448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
70449   void * jresult ;
70450   Dali::BaseHandle arg1 ;
70451   Dali::BaseHandle *argp1 ;
70452   Dali::Toolkit::FlexContainer result;
70453
70454   argp1 = (Dali::BaseHandle *)jarg1;
70455   if (!argp1) {
70456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70457     return 0;
70458   }
70459   arg1 = *argp1;
70460   {
70461     try {
70462       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
70463     } catch (std::out_of_range& e) {
70464       {
70465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70466       };
70467     } catch (std::exception& e) {
70468       {
70469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70470       };
70471     } catch (Dali::DaliException e) {
70472       {
70473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70474       };
70475     } catch (...) {
70476       {
70477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70478       };
70479     }
70480   }
70481
70482   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70483   return jresult;
70484 }
70485
70486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
70487   int jresult ;
70488   int result;
70489
70490   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
70491   jresult = (int)result;
70492   return jresult;
70493 }
70494
70495
70496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
70497   int jresult ;
70498   int result;
70499
70500   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
70501   jresult = (int)result;
70502   return jresult;
70503 }
70504
70505
70506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
70507   int jresult ;
70508   int result;
70509
70510   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
70511   jresult = (int)result;
70512   return jresult;
70513 }
70514
70515
70516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
70517   void * jresult ;
70518   Dali::Toolkit::ImageView::Property *result = 0 ;
70519
70520   {
70521     try {
70522       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
70523     } catch (std::out_of_range& e) {
70524       {
70525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70526       };
70527     } catch (std::exception& e) {
70528       {
70529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70530       };
70531     } catch (Dali::DaliException e) {
70532       {
70533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70534       };
70535     } catch (...) {
70536       {
70537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70538       };
70539     }
70540   }
70541
70542   jresult = (void *)result;
70543   return jresult;
70544 }
70545
70546
70547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
70548   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
70549
70550   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
70551   {
70552     try {
70553       delete arg1;
70554     } catch (std::out_of_range& e) {
70555       {
70556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70557       };
70558     } catch (std::exception& e) {
70559       {
70560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70561       };
70562     } catch (Dali::DaliException e) {
70563       {
70564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70565       };
70566     } catch (...) {
70567       {
70568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70569       };
70570     }
70571   }
70572
70573 }
70574
70575
70576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
70577   void * jresult ;
70578   Dali::Toolkit::ImageView *result = 0 ;
70579
70580   {
70581     try {
70582       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
70583     } catch (std::out_of_range& e) {
70584       {
70585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70586       };
70587     } catch (std::exception& e) {
70588       {
70589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70590       };
70591     } catch (Dali::DaliException e) {
70592       {
70593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70594       };
70595     } catch (...) {
70596       {
70597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70598       };
70599     }
70600   }
70601
70602   jresult = (void *)result;
70603   return jresult;
70604 }
70605
70606
70607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
70608   void * jresult ;
70609   Dali::Toolkit::ImageView result;
70610
70611   {
70612     try {
70613       result = Dali::Toolkit::ImageView::New();
70614     } catch (std::out_of_range& e) {
70615       {
70616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70617       };
70618     } catch (std::exception& e) {
70619       {
70620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70621       };
70622     } catch (Dali::DaliException e) {
70623       {
70624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70625       };
70626     } catch (...) {
70627       {
70628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70629       };
70630     }
70631   }
70632
70633   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70634   return jresult;
70635 }
70636
70637
70638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
70639   void * jresult ;
70640   Dali::Image arg1 ;
70641   Dali::Image *argp1 ;
70642   Dali::Toolkit::ImageView result;
70643
70644   argp1 = (Dali::Image *)jarg1;
70645   if (!argp1) {
70646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70647     return 0;
70648   }
70649   arg1 = *argp1;
70650   {
70651     try {
70652       result = Dali::Toolkit::ImageView::New(arg1);
70653     } catch (std::out_of_range& e) {
70654       {
70655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70656       };
70657     } catch (std::exception& e) {
70658       {
70659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70660       };
70661     } catch (Dali::DaliException e) {
70662       {
70663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70664       };
70665     } catch (...) {
70666       {
70667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70668       };
70669     }
70670   }
70671
70672   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70673   return jresult;
70674 }
70675
70676
70677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
70678   void * jresult ;
70679   std::string *arg1 = 0 ;
70680   Dali::Toolkit::ImageView result;
70681
70682   if (!jarg1) {
70683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70684     return 0;
70685   }
70686   std::string arg1_str(jarg1);
70687   arg1 = &arg1_str;
70688   {
70689     try {
70690       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
70691     } catch (std::out_of_range& e) {
70692       {
70693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70694       };
70695     } catch (std::exception& e) {
70696       {
70697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70698       };
70699     } catch (Dali::DaliException e) {
70700       {
70701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70702       };
70703     } catch (...) {
70704       {
70705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70706       };
70707     }
70708   }
70709
70710   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70711
70712   //argout typemap for const std::string&
70713
70714   return jresult;
70715 }
70716
70717
70718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
70719   void * jresult ;
70720   std::string *arg1 = 0 ;
70721   Dali::ImageDimensions arg2 ;
70722   Dali::ImageDimensions *argp2 ;
70723   Dali::Toolkit::ImageView result;
70724
70725   if (!jarg1) {
70726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70727     return 0;
70728   }
70729   std::string arg1_str(jarg1);
70730   arg1 = &arg1_str;
70731   argp2 = (Dali::ImageDimensions *)jarg2;
70732   if (!argp2) {
70733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
70734     return 0;
70735   }
70736   arg2 = *argp2;
70737   {
70738     try {
70739       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
70740     } catch (std::out_of_range& e) {
70741       {
70742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70743       };
70744     } catch (std::exception& e) {
70745       {
70746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70747       };
70748     } catch (Dali::DaliException e) {
70749       {
70750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70751       };
70752     } catch (...) {
70753       {
70754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70755       };
70756     }
70757   }
70758
70759   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70760
70761   //argout typemap for const std::string&
70762
70763   return jresult;
70764 }
70765
70766
70767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
70768   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70769
70770   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70771   {
70772     try {
70773       delete arg1;
70774     } catch (std::out_of_range& e) {
70775       {
70776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70777       };
70778     } catch (std::exception& e) {
70779       {
70780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70781       };
70782     } catch (Dali::DaliException e) {
70783       {
70784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70785       };
70786     } catch (...) {
70787       {
70788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70789       };
70790     }
70791   }
70792
70793 }
70794
70795
70796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
70797   void * jresult ;
70798   Dali::Toolkit::ImageView *arg1 = 0 ;
70799   Dali::Toolkit::ImageView *result = 0 ;
70800
70801   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70802   if (!arg1) {
70803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70804     return 0;
70805   }
70806   {
70807     try {
70808       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
70809     } catch (std::out_of_range& e) {
70810       {
70811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70812       };
70813     } catch (std::exception& e) {
70814       {
70815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70816       };
70817     } catch (Dali::DaliException e) {
70818       {
70819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70820       };
70821     } catch (...) {
70822       {
70823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70824       };
70825     }
70826   }
70827
70828   jresult = (void *)result;
70829   return jresult;
70830 }
70831
70832
70833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
70834   void * jresult ;
70835   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70836   Dali::Toolkit::ImageView *arg2 = 0 ;
70837   Dali::Toolkit::ImageView *result = 0 ;
70838
70839   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70840   arg2 = (Dali::Toolkit::ImageView *)jarg2;
70841   if (!arg2) {
70842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70843     return 0;
70844   }
70845   {
70846     try {
70847       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
70848     } catch (std::out_of_range& e) {
70849       {
70850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70851       };
70852     } catch (std::exception& e) {
70853       {
70854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70855       };
70856     } catch (Dali::DaliException e) {
70857       {
70858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70859       };
70860     } catch (...) {
70861       {
70862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70863       };
70864     }
70865   }
70866
70867   jresult = (void *)result;
70868   return jresult;
70869 }
70870
70871
70872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
70873   void * jresult ;
70874   Dali::BaseHandle arg1 ;
70875   Dali::BaseHandle *argp1 ;
70876   Dali::Toolkit::ImageView result;
70877
70878   argp1 = (Dali::BaseHandle *)jarg1;
70879   if (!argp1) {
70880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70881     return 0;
70882   }
70883   arg1 = *argp1;
70884   {
70885     try {
70886       result = Dali::Toolkit::ImageView::DownCast(arg1);
70887     } catch (std::out_of_range& e) {
70888       {
70889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70890       };
70891     } catch (std::exception& e) {
70892       {
70893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70894       };
70895     } catch (Dali::DaliException e) {
70896       {
70897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70898       };
70899     } catch (...) {
70900       {
70901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70902       };
70903     }
70904   }
70905
70906   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70907   return jresult;
70908 }
70909
70910
70911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
70912   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70913   Dali::Image arg2 ;
70914   Dali::Image *argp2 ;
70915
70916   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70917   argp2 = (Dali::Image *)jarg2;
70918   if (!argp2) {
70919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70920     return ;
70921   }
70922   arg2 = *argp2;
70923   {
70924     try {
70925       (arg1)->SetImage(arg2);
70926     } catch (std::out_of_range& e) {
70927       {
70928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70929       };
70930     } catch (std::exception& e) {
70931       {
70932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70933       };
70934     } catch (Dali::DaliException e) {
70935       {
70936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70937       };
70938     } catch (...) {
70939       {
70940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70941       };
70942     }
70943   }
70944
70945 }
70946
70947
70948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
70949   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70950   std::string *arg2 = 0 ;
70951
70952   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70953   if (!jarg2) {
70954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70955     return ;
70956   }
70957   std::string arg2_str(jarg2);
70958   arg2 = &arg2_str;
70959   {
70960     try {
70961       (arg1)->SetImage((std::string const &)*arg2);
70962     } catch (std::out_of_range& e) {
70963       {
70964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70965       };
70966     } catch (std::exception& e) {
70967       {
70968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70969       };
70970     } catch (Dali::DaliException e) {
70971       {
70972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70973       };
70974     } catch (...) {
70975       {
70976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70977       };
70978     }
70979   }
70980
70981
70982   //argout typemap for const std::string&
70983
70984 }
70985
70986
70987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
70988   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70989   std::string *arg2 = 0 ;
70990   Dali::ImageDimensions arg3 ;
70991   Dali::ImageDimensions *argp3 ;
70992
70993   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70994   if (!jarg2) {
70995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70996     return ;
70997   }
70998   std::string arg2_str(jarg2);
70999   arg2 = &arg2_str;
71000   argp3 = (Dali::ImageDimensions *)jarg3;
71001   if (!argp3) {
71002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71003     return ;
71004   }
71005   arg3 = *argp3;
71006   {
71007     try {
71008       (arg1)->SetImage((std::string const &)*arg2,arg3);
71009     } catch (std::out_of_range& e) {
71010       {
71011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71012       };
71013     } catch (std::exception& e) {
71014       {
71015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71016       };
71017     } catch (Dali::DaliException e) {
71018       {
71019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71020       };
71021     } catch (...) {
71022       {
71023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71024       };
71025     }
71026   }
71027
71028
71029   //argout typemap for const std::string&
71030
71031 }
71032
71033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
71034   void * jresult ;
71035   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71036   Dali::Image result;
71037
71038   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71039   {
71040     try {
71041       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
71042     } catch (std::out_of_range& e) {
71043       {
71044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71045       };
71046     } catch (std::exception& e) {
71047       {
71048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71049       };
71050     } catch (Dali::DaliException e) {
71051       {
71052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71053       };
71054     } catch (...) {
71055       {
71056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71057       };
71058     }
71059   }
71060
71061   jresult = new Dali::Image((const Dali::Image &)result);
71062   return jresult;
71063 }
71064
71065
71066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
71067   int jresult ;
71068   int result;
71069
71070   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
71071   jresult = (int)result;
71072   return jresult;
71073 }
71074
71075
71076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
71077   int jresult ;
71078   int result;
71079
71080   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
71081   jresult = (int)result;
71082   return jresult;
71083 }
71084
71085
71086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
71087   int jresult ;
71088   int result;
71089
71090   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
71091   jresult = (int)result;
71092   return jresult;
71093 }
71094
71095
71096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
71097   int jresult ;
71098   int result;
71099
71100   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
71101   jresult = (int)result;
71102   return jresult;
71103 }
71104
71105
71106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
71107   int jresult ;
71108   int result;
71109
71110   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
71111   jresult = (int)result;
71112   return jresult;
71113 }
71114
71115
71116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
71117   int jresult ;
71118   int result;
71119
71120   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
71121   jresult = (int)result;
71122   return jresult;
71123 }
71124
71125
71126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
71127   int jresult ;
71128   int result;
71129
71130   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
71131   jresult = (int)result;
71132   return jresult;
71133 }
71134
71135
71136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
71137   int jresult ;
71138   int result;
71139
71140   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
71141   jresult = (int)result;
71142   return jresult;
71143 }
71144
71145
71146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
71147   void * jresult ;
71148   Dali::Toolkit::Model3dView::Property *result = 0 ;
71149
71150   {
71151     try {
71152       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
71153     } catch (std::out_of_range& e) {
71154       {
71155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71156       };
71157     } catch (std::exception& e) {
71158       {
71159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71160       };
71161     } catch (Dali::DaliException e) {
71162       {
71163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71164       };
71165     } catch (...) {
71166       {
71167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71168       };
71169     }
71170   }
71171
71172   jresult = (void *)result;
71173   return jresult;
71174 }
71175
71176
71177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
71178   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
71179
71180   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
71181   {
71182     try {
71183       delete arg1;
71184     } catch (std::out_of_range& e) {
71185       {
71186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71187       };
71188     } catch (std::exception& e) {
71189       {
71190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71191       };
71192     } catch (Dali::DaliException e) {
71193       {
71194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71195       };
71196     } catch (...) {
71197       {
71198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71199       };
71200     }
71201   }
71202
71203 }
71204
71205
71206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
71207   void * jresult ;
71208   Dali::Toolkit::Model3dView result;
71209
71210   {
71211     try {
71212       result = Dali::Toolkit::Model3dView::New();
71213     } catch (std::out_of_range& e) {
71214       {
71215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71216       };
71217     } catch (std::exception& e) {
71218       {
71219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71220       };
71221     } catch (Dali::DaliException e) {
71222       {
71223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71224       };
71225     } catch (...) {
71226       {
71227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71228       };
71229     }
71230   }
71231
71232   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71233   return jresult;
71234 }
71235
71236
71237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
71238   void * jresult ;
71239   std::string *arg1 = 0 ;
71240   std::string *arg2 = 0 ;
71241   std::string *arg3 = 0 ;
71242   Dali::Toolkit::Model3dView result;
71243
71244   if (!jarg1) {
71245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71246     return 0;
71247   }
71248   std::string arg1_str(jarg1);
71249   arg1 = &arg1_str;
71250   if (!jarg2) {
71251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71252     return 0;
71253   }
71254   std::string arg2_str(jarg2);
71255   arg2 = &arg2_str;
71256   if (!jarg3) {
71257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71258     return 0;
71259   }
71260   std::string arg3_str(jarg3);
71261   arg3 = &arg3_str;
71262   {
71263     try {
71264       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
71265     } catch (std::out_of_range& e) {
71266       {
71267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71268       };
71269     } catch (std::exception& e) {
71270       {
71271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71272       };
71273     } catch (Dali::DaliException e) {
71274       {
71275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71276       };
71277     } catch (...) {
71278       {
71279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71280       };
71281     }
71282   }
71283
71284   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71285
71286   //argout typemap for const std::string&
71287
71288
71289   //argout typemap for const std::string&
71290
71291
71292   //argout typemap for const std::string&
71293
71294   return jresult;
71295 }
71296
71297
71298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
71299   void * jresult ;
71300   Dali::Toolkit::Model3dView *result = 0 ;
71301
71302   {
71303     try {
71304       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
71305     } catch (std::out_of_range& e) {
71306       {
71307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71308       };
71309     } catch (std::exception& e) {
71310       {
71311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71312       };
71313     } catch (Dali::DaliException e) {
71314       {
71315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71316       };
71317     } catch (...) {
71318       {
71319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71320       };
71321     }
71322   }
71323
71324   jresult = (void *)result;
71325   return jresult;
71326 }
71327
71328
71329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
71330   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71331
71332   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71333   {
71334     try {
71335       delete arg1;
71336     } catch (std::out_of_range& e) {
71337       {
71338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71339       };
71340     } catch (std::exception& e) {
71341       {
71342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71343       };
71344     } catch (Dali::DaliException e) {
71345       {
71346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71347       };
71348     } catch (...) {
71349       {
71350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71351       };
71352     }
71353   }
71354
71355 }
71356
71357
71358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
71359   void * jresult ;
71360   Dali::Toolkit::Model3dView *arg1 = 0 ;
71361   Dali::Toolkit::Model3dView *result = 0 ;
71362
71363   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71364   if (!arg1) {
71365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71366     return 0;
71367   }
71368   {
71369     try {
71370       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
71371     } catch (std::out_of_range& e) {
71372       {
71373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71374       };
71375     } catch (std::exception& e) {
71376       {
71377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71378       };
71379     } catch (Dali::DaliException e) {
71380       {
71381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71382       };
71383     } catch (...) {
71384       {
71385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71386       };
71387     }
71388   }
71389
71390   jresult = (void *)result;
71391   return jresult;
71392 }
71393
71394
71395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
71396   void * jresult ;
71397   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71398   Dali::Toolkit::Model3dView *arg2 = 0 ;
71399   Dali::Toolkit::Model3dView *result = 0 ;
71400
71401   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71402   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
71403   if (!arg2) {
71404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71405     return 0;
71406   }
71407   {
71408     try {
71409       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
71410     } catch (std::out_of_range& e) {
71411       {
71412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71413       };
71414     } catch (std::exception& e) {
71415       {
71416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71417       };
71418     } catch (Dali::DaliException e) {
71419       {
71420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71421       };
71422     } catch (...) {
71423       {
71424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71425       };
71426     }
71427   }
71428
71429   jresult = (void *)result;
71430   return jresult;
71431 }
71432
71433
71434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
71435   void * jresult ;
71436   Dali::BaseHandle arg1 ;
71437   Dali::BaseHandle *argp1 ;
71438   Dali::Toolkit::Model3dView result;
71439
71440   argp1 = (Dali::BaseHandle *)jarg1;
71441   if (!argp1) {
71442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71443     return 0;
71444   }
71445   arg1 = *argp1;
71446   {
71447     try {
71448       result = Dali::Toolkit::Model3dView::DownCast(arg1);
71449     } catch (std::out_of_range& e) {
71450       {
71451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71452       };
71453     } catch (std::exception& e) {
71454       {
71455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71456       };
71457     } catch (Dali::DaliException e) {
71458       {
71459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71460       };
71461     } catch (...) {
71462       {
71463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71464       };
71465     }
71466   }
71467
71468   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71469   return jresult;
71470 }
71471
71472
71473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
71474   int jresult ;
71475   int result;
71476
71477   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
71478   jresult = (int)result;
71479   return jresult;
71480 }
71481
71482
71483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
71484   int jresult ;
71485   int result;
71486
71487   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
71488   jresult = (int)result;
71489   return jresult;
71490 }
71491
71492
71493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
71494   int jresult ;
71495   int result;
71496
71497   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
71498   jresult = (int)result;
71499   return jresult;
71500 }
71501
71502
71503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
71504   int jresult ;
71505   int result;
71506
71507   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
71508   jresult = (int)result;
71509   return jresult;
71510 }
71511
71512
71513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
71514   int jresult ;
71515   int result;
71516
71517   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
71518   jresult = (int)result;
71519   return jresult;
71520 }
71521
71522
71523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
71524   int jresult ;
71525   int result;
71526
71527   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
71528   jresult = (int)result;
71529   return jresult;
71530 }
71531
71532
71533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
71534   int jresult ;
71535   int result;
71536
71537   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
71538   jresult = (int)result;
71539   return jresult;
71540 }
71541
71542
71543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
71544   int jresult ;
71545   int result;
71546
71547   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
71548   jresult = (int)result;
71549   return jresult;
71550 }
71551
71552
71553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
71554   int jresult ;
71555   int result;
71556
71557   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
71558   jresult = (int)result;
71559   return jresult;
71560 }
71561
71562
71563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
71564   void * jresult ;
71565   Dali::Toolkit::ScrollBar::Property *result = 0 ;
71566
71567   {
71568     try {
71569       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
71570     } catch (std::out_of_range& e) {
71571       {
71572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71573       };
71574     } catch (std::exception& e) {
71575       {
71576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71577       };
71578     } catch (Dali::DaliException e) {
71579       {
71580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71581       };
71582     } catch (...) {
71583       {
71584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71585       };
71586     }
71587   }
71588
71589   jresult = (void *)result;
71590   return jresult;
71591 }
71592
71593
71594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
71595   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
71596
71597   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
71598   {
71599     try {
71600       delete arg1;
71601     } catch (std::out_of_range& e) {
71602       {
71603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71604       };
71605     } catch (std::exception& e) {
71606       {
71607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71608       };
71609     } catch (Dali::DaliException e) {
71610       {
71611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71612       };
71613     } catch (...) {
71614       {
71615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71616       };
71617     }
71618   }
71619
71620 }
71621
71622
71623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
71624   void * jresult ;
71625   Dali::Toolkit::ScrollBar *result = 0 ;
71626
71627   {
71628     try {
71629       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
71630     } catch (std::out_of_range& e) {
71631       {
71632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71633       };
71634     } catch (std::exception& e) {
71635       {
71636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71637       };
71638     } catch (Dali::DaliException e) {
71639       {
71640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71641       };
71642     } catch (...) {
71643       {
71644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71645       };
71646     }
71647   }
71648
71649   jresult = (void *)result;
71650   return jresult;
71651 }
71652
71653
71654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
71655   void * jresult ;
71656   Dali::Toolkit::ScrollBar *arg1 = 0 ;
71657   Dali::Toolkit::ScrollBar *result = 0 ;
71658
71659   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71660   if (!arg1) {
71661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71662     return 0;
71663   }
71664   {
71665     try {
71666       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
71667     } catch (std::out_of_range& e) {
71668       {
71669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71670       };
71671     } catch (std::exception& e) {
71672       {
71673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71674       };
71675     } catch (Dali::DaliException e) {
71676       {
71677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71678       };
71679     } catch (...) {
71680       {
71681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71682       };
71683     }
71684   }
71685
71686   jresult = (void *)result;
71687   return jresult;
71688 }
71689
71690
71691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
71692   void * jresult ;
71693   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71694   Dali::Toolkit::ScrollBar *arg2 = 0 ;
71695   Dali::Toolkit::ScrollBar *result = 0 ;
71696
71697   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71698   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
71699   if (!arg2) {
71700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71701     return 0;
71702   }
71703   {
71704     try {
71705       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
71706     } catch (std::out_of_range& e) {
71707       {
71708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71709       };
71710     } catch (std::exception& e) {
71711       {
71712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71713       };
71714     } catch (Dali::DaliException e) {
71715       {
71716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71717       };
71718     } catch (...) {
71719       {
71720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71721       };
71722     }
71723   }
71724
71725   jresult = (void *)result;
71726   return jresult;
71727 }
71728
71729
71730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
71731   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71732
71733   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71734   {
71735     try {
71736       delete arg1;
71737     } catch (std::out_of_range& e) {
71738       {
71739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71740       };
71741     } catch (std::exception& e) {
71742       {
71743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71744       };
71745     } catch (Dali::DaliException e) {
71746       {
71747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71748       };
71749     } catch (...) {
71750       {
71751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71752       };
71753     }
71754   }
71755
71756 }
71757
71758
71759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
71760   void * jresult ;
71761   Dali::Toolkit::ScrollBar::Direction arg1 ;
71762   Dali::Toolkit::ScrollBar result;
71763
71764   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
71765   {
71766     try {
71767       result = Dali::Toolkit::ScrollBar::New(arg1);
71768     } catch (std::out_of_range& e) {
71769       {
71770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71771       };
71772     } catch (std::exception& e) {
71773       {
71774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71775       };
71776     } catch (Dali::DaliException e) {
71777       {
71778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71779       };
71780     } catch (...) {
71781       {
71782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71783       };
71784     }
71785   }
71786
71787   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71788   return jresult;
71789 }
71790
71791
71792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
71793   void * jresult ;
71794   Dali::Toolkit::ScrollBar result;
71795
71796   {
71797     try {
71798       result = Dali::Toolkit::ScrollBar::New();
71799     } catch (std::out_of_range& e) {
71800       {
71801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71802       };
71803     } catch (std::exception& e) {
71804       {
71805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71806       };
71807     } catch (Dali::DaliException e) {
71808       {
71809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71810       };
71811     } catch (...) {
71812       {
71813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71814       };
71815     }
71816   }
71817
71818   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71819   return jresult;
71820 }
71821
71822
71823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
71824   void * jresult ;
71825   Dali::BaseHandle arg1 ;
71826   Dali::BaseHandle *argp1 ;
71827   Dali::Toolkit::ScrollBar result;
71828
71829   argp1 = (Dali::BaseHandle *)jarg1;
71830   if (!argp1) {
71831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71832     return 0;
71833   }
71834   arg1 = *argp1;
71835   {
71836     try {
71837       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
71838     } catch (std::out_of_range& e) {
71839       {
71840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71841       };
71842     } catch (std::exception& e) {
71843       {
71844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71845       };
71846     } catch (Dali::DaliException e) {
71847       {
71848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71849       };
71850     } catch (...) {
71851       {
71852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71853       };
71854     }
71855   }
71856
71857   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71858   return jresult;
71859 }
71860
71861
71862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
71863   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71864   Dali::Handle arg2 ;
71865   Dali::Property::Index arg3 ;
71866   Dali::Property::Index arg4 ;
71867   Dali::Property::Index arg5 ;
71868   Dali::Property::Index arg6 ;
71869   Dali::Handle *argp2 ;
71870
71871   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71872   argp2 = (Dali::Handle *)jarg2;
71873   if (!argp2) {
71874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
71875     return ;
71876   }
71877   arg2 = *argp2;
71878   arg3 = (Dali::Property::Index)jarg3;
71879   arg4 = (Dali::Property::Index)jarg4;
71880   arg5 = (Dali::Property::Index)jarg5;
71881   arg6 = (Dali::Property::Index)jarg6;
71882   {
71883     try {
71884       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
71885     } catch (std::out_of_range& e) {
71886       {
71887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71888       };
71889     } catch (std::exception& e) {
71890       {
71891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71892       };
71893     } catch (Dali::DaliException e) {
71894       {
71895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71896       };
71897     } catch (...) {
71898       {
71899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71900       };
71901     }
71902   }
71903
71904 }
71905
71906
71907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
71908   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71909   Dali::Actor arg2 ;
71910   Dali::Actor *argp2 ;
71911
71912   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71913   argp2 = (Dali::Actor *)jarg2;
71914   if (!argp2) {
71915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71916     return ;
71917   }
71918   arg2 = *argp2;
71919   {
71920     try {
71921       (arg1)->SetScrollIndicator(arg2);
71922     } catch (std::out_of_range& e) {
71923       {
71924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71925       };
71926     } catch (std::exception& e) {
71927       {
71928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71929       };
71930     } catch (Dali::DaliException e) {
71931       {
71932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71933       };
71934     } catch (...) {
71935       {
71936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71937       };
71938     }
71939   }
71940
71941 }
71942
71943
71944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
71945   void * jresult ;
71946   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71947   Dali::Actor result;
71948
71949   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71950   {
71951     try {
71952       result = (arg1)->GetScrollIndicator();
71953     } catch (std::out_of_range& e) {
71954       {
71955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71956       };
71957     } catch (std::exception& e) {
71958       {
71959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71960       };
71961     } catch (Dali::DaliException e) {
71962       {
71963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71964       };
71965     } catch (...) {
71966       {
71967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71968       };
71969     }
71970   }
71971
71972   jresult = new Dali::Actor((const Dali::Actor &)result);
71973   return jresult;
71974 }
71975
71976
71977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
71978   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71979   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
71980
71981   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71982   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
71983   if (!arg2) {
71984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
71985     return ;
71986   }
71987   {
71988     try {
71989       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
71990     } catch (std::out_of_range& e) {
71991       {
71992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71993       };
71994     } catch (std::exception& e) {
71995       {
71996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71997       };
71998     } catch (Dali::DaliException e) {
71999       {
72000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72001       };
72002     } catch (...) {
72003       {
72004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72005       };
72006     }
72007   }
72008
72009 }
72010
72011
72012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
72013   void * jresult ;
72014   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72015
72016   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72017   {
72018     try {
72019       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()));
72020     } catch (std::out_of_range& e) {
72021       {
72022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72023       };
72024     } catch (std::exception& e) {
72025       {
72026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72027       };
72028     } catch (...) {
72029       {
72030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72031       };
72032     }
72033   }
72034   return jresult;
72035 }
72036
72037
72038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
72039   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72040   Dali::Toolkit::ScrollBar::Direction arg2 ;
72041
72042   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72043   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
72044   {
72045     try {
72046       (arg1)->SetScrollDirection(arg2);
72047     } catch (std::out_of_range& e) {
72048       {
72049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72050       };
72051     } catch (std::exception& e) {
72052       {
72053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72054       };
72055     } catch (Dali::DaliException e) {
72056       {
72057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72058       };
72059     } catch (...) {
72060       {
72061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72062       };
72063     }
72064   }
72065
72066 }
72067
72068
72069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
72070   int jresult ;
72071   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72072   Dali::Toolkit::ScrollBar::Direction result;
72073
72074   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72075   {
72076     try {
72077       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
72078     } catch (std::out_of_range& e) {
72079       {
72080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72081       };
72082     } catch (std::exception& e) {
72083       {
72084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72085       };
72086     } catch (Dali::DaliException e) {
72087       {
72088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72089       };
72090     } catch (...) {
72091       {
72092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72093       };
72094     }
72095   }
72096
72097   jresult = (int)result;
72098   return jresult;
72099 }
72100
72101
72102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
72103   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72104   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
72105
72106   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72107   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
72108   {
72109     try {
72110       (arg1)->SetIndicatorHeightPolicy(arg2);
72111     } catch (std::out_of_range& e) {
72112       {
72113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72114       };
72115     } catch (std::exception& e) {
72116       {
72117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72118       };
72119     } catch (Dali::DaliException e) {
72120       {
72121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72122       };
72123     } catch (...) {
72124       {
72125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72126       };
72127     }
72128   }
72129
72130 }
72131
72132
72133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
72134   int jresult ;
72135   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72136   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
72137
72138   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72139   {
72140     try {
72141       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
72142     } catch (std::out_of_range& e) {
72143       {
72144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72145       };
72146     } catch (std::exception& e) {
72147       {
72148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72149       };
72150     } catch (Dali::DaliException e) {
72151       {
72152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72153       };
72154     } catch (...) {
72155       {
72156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72157       };
72158     }
72159   }
72160
72161   jresult = (int)result;
72162   return jresult;
72163 }
72164
72165
72166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
72167   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72168   float arg2 ;
72169
72170   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72171   arg2 = (float)jarg2;
72172   {
72173     try {
72174       (arg1)->SetIndicatorFixedHeight(arg2);
72175     } catch (std::out_of_range& e) {
72176       {
72177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72178       };
72179     } catch (std::exception& e) {
72180       {
72181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72182       };
72183     } catch (Dali::DaliException e) {
72184       {
72185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72186       };
72187     } catch (...) {
72188       {
72189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72190       };
72191     }
72192   }
72193
72194 }
72195
72196
72197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
72198   float jresult ;
72199   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72200   float result;
72201
72202   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72203   {
72204     try {
72205       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
72206     } catch (std::out_of_range& e) {
72207       {
72208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72209       };
72210     } catch (std::exception& e) {
72211       {
72212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72213       };
72214     } catch (Dali::DaliException e) {
72215       {
72216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72217       };
72218     } catch (...) {
72219       {
72220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72221       };
72222     }
72223   }
72224
72225   jresult = result;
72226   return jresult;
72227 }
72228
72229
72230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
72231   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72232   float arg2 ;
72233
72234   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72235   arg2 = (float)jarg2;
72236   {
72237     try {
72238       (arg1)->SetIndicatorShowDuration(arg2);
72239     } catch (std::out_of_range& e) {
72240       {
72241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72242       };
72243     } catch (std::exception& e) {
72244       {
72245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72246       };
72247     } catch (Dali::DaliException e) {
72248       {
72249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72250       };
72251     } catch (...) {
72252       {
72253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72254       };
72255     }
72256   }
72257
72258 }
72259
72260
72261 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
72262   float jresult ;
72263   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72264   float result;
72265
72266   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72267   {
72268     try {
72269       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
72270     } catch (std::out_of_range& e) {
72271       {
72272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72273       };
72274     } catch (std::exception& e) {
72275       {
72276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72277       };
72278     } catch (Dali::DaliException e) {
72279       {
72280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72281       };
72282     } catch (...) {
72283       {
72284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72285       };
72286     }
72287   }
72288
72289   jresult = result;
72290   return jresult;
72291 }
72292
72293
72294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
72295   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72296   float arg2 ;
72297
72298   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72299   arg2 = (float)jarg2;
72300   {
72301     try {
72302       (arg1)->SetIndicatorHideDuration(arg2);
72303     } catch (std::out_of_range& e) {
72304       {
72305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72306       };
72307     } catch (std::exception& e) {
72308       {
72309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72310       };
72311     } catch (Dali::DaliException e) {
72312       {
72313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72314       };
72315     } catch (...) {
72316       {
72317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72318       };
72319     }
72320   }
72321
72322 }
72323
72324
72325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
72326   float jresult ;
72327   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72328   float result;
72329
72330   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72331   {
72332     try {
72333       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
72334     } catch (std::out_of_range& e) {
72335       {
72336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72337       };
72338     } catch (std::exception& e) {
72339       {
72340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72341       };
72342     } catch (Dali::DaliException e) {
72343       {
72344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72345       };
72346     } catch (...) {
72347       {
72348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72349       };
72350     }
72351   }
72352
72353   jresult = result;
72354   return jresult;
72355 }
72356
72357
72358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
72359   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72360
72361   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72362   {
72363     try {
72364       (arg1)->ShowIndicator();
72365     } catch (std::out_of_range& e) {
72366       {
72367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72368       };
72369     } catch (std::exception& e) {
72370       {
72371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72372       };
72373     } catch (Dali::DaliException e) {
72374       {
72375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72376       };
72377     } catch (...) {
72378       {
72379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72380       };
72381     }
72382   }
72383
72384 }
72385
72386
72387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
72388   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72389
72390   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72391   {
72392     try {
72393       (arg1)->HideIndicator();
72394     } catch (std::out_of_range& e) {
72395       {
72396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72397       };
72398     } catch (std::exception& e) {
72399       {
72400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72401       };
72402     } catch (Dali::DaliException e) {
72403       {
72404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72405       };
72406     } catch (...) {
72407       {
72408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72409       };
72410     }
72411   }
72412
72413 }
72414
72415
72416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
72417   void * jresult ;
72418   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72419   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
72420
72421   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72422   {
72423     try {
72424       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
72425     } catch (std::out_of_range& e) {
72426       {
72427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72428       };
72429     } catch (std::exception& e) {
72430       {
72431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72432       };
72433     } catch (Dali::DaliException e) {
72434       {
72435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72436       };
72437     } catch (...) {
72438       {
72439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72440       };
72441     }
72442   }
72443
72444   jresult = (void *)result;
72445   return jresult;
72446 }
72447
72448
72449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
72450   void * jresult ;
72451   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72452   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
72453
72454   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72455   {
72456     try {
72457       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
72458     } catch (std::out_of_range& e) {
72459       {
72460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72461       };
72462     } catch (std::exception& e) {
72463       {
72464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72465       };
72466     } catch (Dali::DaliException e) {
72467       {
72468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72469       };
72470     } catch (...) {
72471       {
72472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72473       };
72474     }
72475   }
72476
72477   jresult = (void *)result;
72478   return jresult;
72479 }
72480
72481
72482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
72483   int jresult ;
72484   int result;
72485
72486   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
72487   jresult = (int)result;
72488   return jresult;
72489 }
72490
72491
72492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
72493   int jresult ;
72494   int result;
72495
72496   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
72497   jresult = (int)result;
72498   return jresult;
72499 }
72500
72501
72502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
72503   int jresult ;
72504   int result;
72505
72506   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
72507   jresult = (int)result;
72508   return jresult;
72509 }
72510
72511
72512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
72513   int jresult ;
72514   int result;
72515
72516   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
72517   jresult = (int)result;
72518   return jresult;
72519 }
72520
72521
72522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
72523   int jresult ;
72524   int result;
72525
72526   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
72527   jresult = (int)result;
72528   return jresult;
72529 }
72530
72531
72532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
72533   int jresult ;
72534   int result;
72535
72536   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
72537   jresult = (int)result;
72538   return jresult;
72539 }
72540
72541
72542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
72543   int jresult ;
72544   int result;
72545
72546   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
72547   jresult = (int)result;
72548   return jresult;
72549 }
72550
72551
72552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
72553   int jresult ;
72554   int result;
72555
72556   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
72557   jresult = (int)result;
72558   return jresult;
72559 }
72560
72561
72562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
72563   int jresult ;
72564   int result;
72565
72566   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
72567   jresult = (int)result;
72568   return jresult;
72569 }
72570
72571
72572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
72573   int jresult ;
72574   int result;
72575
72576   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
72577   jresult = (int)result;
72578   return jresult;
72579 }
72580
72581
72582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
72583   int jresult ;
72584   int result;
72585
72586   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
72587   jresult = (int)result;
72588   return jresult;
72589 }
72590
72591
72592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
72593   int jresult ;
72594   int result;
72595
72596   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
72597   jresult = (int)result;
72598   return jresult;
72599 }
72600
72601
72602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
72603   int jresult ;
72604   int result;
72605
72606   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
72607   jresult = (int)result;
72608   return jresult;
72609 }
72610
72611
72612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
72613   int jresult ;
72614   int result;
72615
72616   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
72617   jresult = (int)result;
72618   return jresult;
72619 }
72620
72621
72622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
72623   void * jresult ;
72624   Dali::Toolkit::Scrollable::Property *result = 0 ;
72625
72626   {
72627     try {
72628       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
72629     } catch (std::out_of_range& e) {
72630       {
72631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72632       };
72633     } catch (std::exception& e) {
72634       {
72635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72636       };
72637     } catch (Dali::DaliException e) {
72638       {
72639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72640       };
72641     } catch (...) {
72642       {
72643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72644       };
72645     }
72646   }
72647
72648   jresult = (void *)result;
72649   return jresult;
72650 }
72651
72652
72653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
72654   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
72655
72656   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
72657   {
72658     try {
72659       delete arg1;
72660     } catch (std::out_of_range& e) {
72661       {
72662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72663       };
72664     } catch (std::exception& e) {
72665       {
72666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72667       };
72668     } catch (Dali::DaliException e) {
72669       {
72670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72671       };
72672     } catch (...) {
72673       {
72674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72675       };
72676     }
72677   }
72678
72679 }
72680
72681
72682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
72683   void * jresult ;
72684   Dali::Toolkit::Scrollable *result = 0 ;
72685
72686   {
72687     try {
72688       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
72689     } catch (std::out_of_range& e) {
72690       {
72691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72692       };
72693     } catch (std::exception& e) {
72694       {
72695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72696       };
72697     } catch (Dali::DaliException e) {
72698       {
72699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72700       };
72701     } catch (...) {
72702       {
72703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72704       };
72705     }
72706   }
72707
72708   jresult = (void *)result;
72709   return jresult;
72710 }
72711
72712
72713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
72714   void * jresult ;
72715   Dali::Toolkit::Scrollable *arg1 = 0 ;
72716   Dali::Toolkit::Scrollable *result = 0 ;
72717
72718   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72719   if (!arg1) {
72720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72721     return 0;
72722   }
72723   {
72724     try {
72725       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
72726     } catch (std::out_of_range& e) {
72727       {
72728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72729       };
72730     } catch (std::exception& e) {
72731       {
72732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72733       };
72734     } catch (Dali::DaliException e) {
72735       {
72736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72737       };
72738     } catch (...) {
72739       {
72740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72741       };
72742     }
72743   }
72744
72745   jresult = (void *)result;
72746   return jresult;
72747 }
72748
72749
72750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
72751   void * jresult ;
72752   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72753   Dali::Toolkit::Scrollable *arg2 = 0 ;
72754   Dali::Toolkit::Scrollable *result = 0 ;
72755
72756   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72757   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
72758   if (!arg2) {
72759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72760     return 0;
72761   }
72762   {
72763     try {
72764       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
72765     } catch (std::out_of_range& e) {
72766       {
72767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72768       };
72769     } catch (std::exception& e) {
72770       {
72771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72772       };
72773     } catch (Dali::DaliException e) {
72774       {
72775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72776       };
72777     } catch (...) {
72778       {
72779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72780       };
72781     }
72782   }
72783
72784   jresult = (void *)result;
72785   return jresult;
72786 }
72787
72788
72789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
72790   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72791
72792   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72793   {
72794     try {
72795       delete arg1;
72796     } catch (std::out_of_range& e) {
72797       {
72798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72799       };
72800     } catch (std::exception& e) {
72801       {
72802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72803       };
72804     } catch (Dali::DaliException e) {
72805       {
72806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72807       };
72808     } catch (...) {
72809       {
72810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72811       };
72812     }
72813   }
72814
72815 }
72816
72817
72818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
72819   void * jresult ;
72820   Dali::BaseHandle arg1 ;
72821   Dali::BaseHandle *argp1 ;
72822   Dali::Toolkit::Scrollable result;
72823
72824   argp1 = (Dali::BaseHandle *)jarg1;
72825   if (!argp1) {
72826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72827     return 0;
72828   }
72829   arg1 = *argp1;
72830   {
72831     try {
72832       result = Dali::Toolkit::Scrollable::DownCast(arg1);
72833     } catch (std::out_of_range& e) {
72834       {
72835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72836       };
72837     } catch (std::exception& e) {
72838       {
72839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72840       };
72841     } catch (Dali::DaliException e) {
72842       {
72843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72844       };
72845     } catch (...) {
72846       {
72847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72848       };
72849     }
72850   }
72851
72852   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
72853   return jresult;
72854 }
72855
72856
72857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
72858   unsigned int jresult ;
72859   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72860   bool result;
72861
72862   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72863   {
72864     try {
72865       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
72866     } catch (std::out_of_range& e) {
72867       {
72868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72869       };
72870     } catch (std::exception& e) {
72871       {
72872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72873       };
72874     } catch (Dali::DaliException e) {
72875       {
72876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72877       };
72878     } catch (...) {
72879       {
72880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72881       };
72882     }
72883   }
72884
72885   jresult = result;
72886   return jresult;
72887 }
72888
72889
72890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
72891   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72892   bool arg2 ;
72893
72894   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72895   arg2 = jarg2 ? true : false;
72896   {
72897     try {
72898       (arg1)->SetOvershootEnabled(arg2);
72899     } catch (std::out_of_range& e) {
72900       {
72901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72902       };
72903     } catch (std::exception& e) {
72904       {
72905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72906       };
72907     } catch (Dali::DaliException e) {
72908       {
72909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72910       };
72911     } catch (...) {
72912       {
72913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72914       };
72915     }
72916   }
72917
72918 }
72919
72920
72921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
72922   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72923   Dali::Vector4 *arg2 = 0 ;
72924
72925   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72926   arg2 = (Dali::Vector4 *)jarg2;
72927   if (!arg2) {
72928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
72929     return ;
72930   }
72931   {
72932     try {
72933       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
72934     } catch (std::out_of_range& e) {
72935       {
72936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72937       };
72938     } catch (std::exception& e) {
72939       {
72940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72941       };
72942     } catch (Dali::DaliException e) {
72943       {
72944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72945       };
72946     } catch (...) {
72947       {
72948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72949       };
72950     }
72951   }
72952
72953 }
72954
72955
72956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
72957   void * jresult ;
72958   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72959   Dali::Vector4 result;
72960
72961   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72962   {
72963     try {
72964       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
72965     } catch (std::out_of_range& e) {
72966       {
72967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72968       };
72969     } catch (std::exception& e) {
72970       {
72971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72972       };
72973     } catch (Dali::DaliException e) {
72974       {
72975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72976       };
72977     } catch (...) {
72978       {
72979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72980       };
72981     }
72982   }
72983
72984   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
72985   return jresult;
72986 }
72987
72988
72989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
72990   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72991   float arg2 ;
72992
72993   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72994   arg2 = (float)jarg2;
72995   {
72996     try {
72997       (arg1)->SetOvershootAnimationSpeed(arg2);
72998     } catch (std::out_of_range& e) {
72999       {
73000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73001       };
73002     } catch (std::exception& e) {
73003       {
73004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73005       };
73006     } catch (Dali::DaliException e) {
73007       {
73008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73009       };
73010     } catch (...) {
73011       {
73012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73013       };
73014     }
73015   }
73016
73017 }
73018
73019
73020 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
73021   float jresult ;
73022   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73023   float result;
73024
73025   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73026   {
73027     try {
73028       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
73029     } catch (std::out_of_range& e) {
73030       {
73031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73032       };
73033     } catch (std::exception& e) {
73034       {
73035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73036       };
73037     } catch (Dali::DaliException e) {
73038       {
73039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73040       };
73041     } catch (...) {
73042       {
73043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73044       };
73045     }
73046   }
73047
73048   jresult = result;
73049   return jresult;
73050 }
73051
73052
73053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
73054   void * jresult ;
73055   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73056   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
73057
73058   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73059   {
73060     try {
73061       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
73062     } catch (std::out_of_range& e) {
73063       {
73064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73065       };
73066     } catch (std::exception& e) {
73067       {
73068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73069       };
73070     } catch (Dali::DaliException e) {
73071       {
73072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73073       };
73074     } catch (...) {
73075       {
73076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73077       };
73078     }
73079   }
73080
73081   jresult = (void *)result;
73082   return jresult;
73083 }
73084
73085
73086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
73087   void * jresult ;
73088   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73089   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
73090
73091   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73092   {
73093     try {
73094       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
73095     } catch (std::out_of_range& e) {
73096       {
73097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73098       };
73099     } catch (std::exception& e) {
73100       {
73101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73102       };
73103     } catch (Dali::DaliException e) {
73104       {
73105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73106       };
73107     } catch (...) {
73108       {
73109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73110       };
73111     }
73112   }
73113
73114   jresult = (void *)result;
73115   return jresult;
73116 }
73117
73118
73119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
73120   void * jresult ;
73121   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73122   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
73123
73124   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73125   {
73126     try {
73127       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
73128     } catch (std::out_of_range& e) {
73129       {
73130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73131       };
73132     } catch (std::exception& e) {
73133       {
73134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73135       };
73136     } catch (Dali::DaliException e) {
73137       {
73138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73139       };
73140     } catch (...) {
73141       {
73142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73143       };
73144     }
73145   }
73146
73147   jresult = (void *)result;
73148   return jresult;
73149 }
73150
73151
73152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
73153   unsigned int jresult ;
73154   Dali::Toolkit::ControlOrientation::Type arg1 ;
73155   bool result;
73156
73157   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
73158   {
73159     try {
73160       result = (bool)Dali::Toolkit::IsVertical(arg1);
73161     } catch (std::out_of_range& e) {
73162       {
73163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73164       };
73165     } catch (std::exception& e) {
73166       {
73167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73168       };
73169     } catch (Dali::DaliException e) {
73170       {
73171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73172       };
73173     } catch (...) {
73174       {
73175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73176       };
73177     }
73178   }
73179
73180   jresult = result;
73181   return jresult;
73182 }
73183
73184
73185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
73186   unsigned int jresult ;
73187   Dali::Toolkit::ControlOrientation::Type arg1 ;
73188   bool result;
73189
73190   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
73191   {
73192     try {
73193       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
73194     } catch (std::out_of_range& e) {
73195       {
73196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73197       };
73198     } catch (std::exception& e) {
73199       {
73200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73201       };
73202     } catch (Dali::DaliException e) {
73203       {
73204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73205       };
73206     } catch (...) {
73207       {
73208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73209       };
73210     }
73211   }
73212
73213   jresult = result;
73214   return jresult;
73215 }
73216
73217
73218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
73219   void * jresult ;
73220   unsigned int arg1 ;
73221   unsigned int arg2 ;
73222   Dali::Toolkit::ItemRange *result = 0 ;
73223
73224   arg1 = (unsigned int)jarg1;
73225   arg2 = (unsigned int)jarg2;
73226   {
73227     try {
73228       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
73229     } catch (std::out_of_range& e) {
73230       {
73231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73232       };
73233     } catch (std::exception& e) {
73234       {
73235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73236       };
73237     } catch (Dali::DaliException e) {
73238       {
73239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73240       };
73241     } catch (...) {
73242       {
73243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73244       };
73245     }
73246   }
73247
73248   jresult = (void *)result;
73249   return jresult;
73250 }
73251
73252
73253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
73254   void * jresult ;
73255   Dali::Toolkit::ItemRange *arg1 = 0 ;
73256   Dali::Toolkit::ItemRange *result = 0 ;
73257
73258   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73259   if (!arg1) {
73260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73261     return 0;
73262   }
73263   {
73264     try {
73265       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
73266     } catch (std::out_of_range& e) {
73267       {
73268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73269       };
73270     } catch (std::exception& e) {
73271       {
73272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73273       };
73274     } catch (Dali::DaliException e) {
73275       {
73276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73277       };
73278     } catch (...) {
73279       {
73280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73281       };
73282     }
73283   }
73284
73285   jresult = (void *)result;
73286   return jresult;
73287 }
73288
73289
73290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
73291   void * jresult ;
73292   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73293   Dali::Toolkit::ItemRange *arg2 = 0 ;
73294   Dali::Toolkit::ItemRange *result = 0 ;
73295
73296   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73297   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73298   if (!arg2) {
73299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73300     return 0;
73301   }
73302   {
73303     try {
73304       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
73305     } catch (std::out_of_range& e) {
73306       {
73307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73308       };
73309     } catch (std::exception& e) {
73310       {
73311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73312       };
73313     } catch (Dali::DaliException e) {
73314       {
73315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73316       };
73317     } catch (...) {
73318       {
73319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73320       };
73321     }
73322   }
73323
73324   jresult = (void *)result;
73325   return jresult;
73326 }
73327
73328
73329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
73330   unsigned int jresult ;
73331   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73332   unsigned int arg2 ;
73333   bool result;
73334
73335   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73336   arg2 = (unsigned int)jarg2;
73337   {
73338     try {
73339       result = (bool)(arg1)->Within(arg2);
73340     } catch (std::out_of_range& e) {
73341       {
73342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73343       };
73344     } catch (std::exception& e) {
73345       {
73346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73347       };
73348     } catch (Dali::DaliException e) {
73349       {
73350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73351       };
73352     } catch (...) {
73353       {
73354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73355       };
73356     }
73357   }
73358
73359   jresult = result;
73360   return jresult;
73361 }
73362
73363
73364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
73365   void * jresult ;
73366   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73367   Dali::Toolkit::ItemRange *arg2 = 0 ;
73368   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73369
73370   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73371   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73372   if (!arg2) {
73373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73374     return 0;
73375   }
73376   {
73377     try {
73378       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
73379     } catch (std::out_of_range& e) {
73380       {
73381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73382       };
73383     } catch (std::exception& e) {
73384       {
73385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73386       };
73387     } catch (Dali::DaliException e) {
73388       {
73389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73390       };
73391     } catch (...) {
73392       {
73393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73394       };
73395     }
73396   }
73397
73398   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73399   return jresult;
73400 }
73401
73402
73403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
73404   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73405   unsigned int arg2 ;
73406
73407   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73408   arg2 = (unsigned int)jarg2;
73409   if (arg1) (arg1)->begin = arg2;
73410 }
73411
73412
73413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
73414   unsigned int jresult ;
73415   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73416   unsigned int result;
73417
73418   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73419   result = (unsigned int) ((arg1)->begin);
73420   jresult = result;
73421   return jresult;
73422 }
73423
73424
73425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
73426   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73427   unsigned int arg2 ;
73428
73429   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73430   arg2 = (unsigned int)jarg2;
73431   if (arg1) (arg1)->end = arg2;
73432 }
73433
73434
73435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
73436   unsigned int jresult ;
73437   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73438   unsigned int result;
73439
73440   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73441   result = (unsigned int) ((arg1)->end);
73442   jresult = result;
73443   return jresult;
73444 }
73445
73446
73447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
73448   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73449
73450   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73451   {
73452     try {
73453       delete arg1;
73454     } catch (std::out_of_range& e) {
73455       {
73456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73457       };
73458     } catch (std::exception& e) {
73459       {
73460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73461       };
73462     } catch (Dali::DaliException e) {
73463       {
73464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73465       };
73466     } catch (...) {
73467       {
73468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73469       };
73470     }
73471   }
73472
73473 }
73474
73475
73476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
73477   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73478
73479   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73480   {
73481     try {
73482       delete arg1;
73483     } catch (std::out_of_range& e) {
73484       {
73485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73486       };
73487     } catch (std::exception& e) {
73488       {
73489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73490       };
73491     } catch (Dali::DaliException e) {
73492       {
73493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73494       };
73495     } catch (...) {
73496       {
73497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73498       };
73499     }
73500   }
73501
73502 }
73503
73504
73505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
73506   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73507   Dali::Toolkit::ControlOrientation::Type arg2 ;
73508
73509   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73510   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
73511   {
73512     try {
73513       (arg1)->SetOrientation(arg2);
73514     } catch (std::out_of_range& e) {
73515       {
73516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73517       };
73518     } catch (std::exception& e) {
73519       {
73520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73521       };
73522     } catch (Dali::DaliException e) {
73523       {
73524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73525       };
73526     } catch (...) {
73527       {
73528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73529       };
73530     }
73531   }
73532
73533 }
73534
73535
73536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
73537   int jresult ;
73538   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73539   Dali::Toolkit::ControlOrientation::Type result;
73540
73541   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73542   {
73543     try {
73544       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
73545     } catch (std::out_of_range& e) {
73546       {
73547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73548       };
73549     } catch (std::exception& e) {
73550       {
73551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73552       };
73553     } catch (Dali::DaliException e) {
73554       {
73555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73556       };
73557     } catch (...) {
73558       {
73559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73560       };
73561     }
73562   }
73563
73564   jresult = (int)result;
73565   return jresult;
73566 }
73567
73568
73569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
73570   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73571   Dali::Property::Map *arg2 = 0 ;
73572
73573   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73574   arg2 = (Dali::Property::Map *)jarg2;
73575   if (!arg2) {
73576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
73577     return ;
73578   }
73579   {
73580     try {
73581       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
73582     } catch (std::out_of_range& e) {
73583       {
73584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73585       };
73586     } catch (std::exception& e) {
73587       {
73588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73589       };
73590     } catch (Dali::DaliException e) {
73591       {
73592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73593       };
73594     } catch (...) {
73595       {
73596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73597       };
73598     }
73599   }
73600
73601 }
73602
73603
73604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
73605   void * jresult ;
73606   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73607   Dali::Property::Map result;
73608
73609   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73610   {
73611     try {
73612       result = (arg1)->GetLayoutProperties();
73613     } catch (std::out_of_range& e) {
73614       {
73615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73616       };
73617     } catch (std::exception& e) {
73618       {
73619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73620       };
73621     } catch (Dali::DaliException e) {
73622       {
73623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73624       };
73625     } catch (...) {
73626       {
73627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73628       };
73629     }
73630   }
73631
73632   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
73633   return jresult;
73634 }
73635
73636
73637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
73638   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73639   unsigned int arg2 ;
73640   Dali::Vector3 *arg3 = 0 ;
73641   Dali::Vector3 *arg4 = 0 ;
73642
73643   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73644   arg2 = (unsigned int)jarg2;
73645   arg3 = (Dali::Vector3 *)jarg3;
73646   if (!arg3) {
73647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73648     return ;
73649   }
73650   arg4 = (Dali::Vector3 *)jarg4;
73651   if (!arg4) {
73652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
73653     return ;
73654   }
73655   {
73656     try {
73657       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
73658     } catch (std::out_of_range& e) {
73659       {
73660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73661       };
73662     } catch (std::exception& e) {
73663       {
73664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73665       };
73666     } catch (Dali::DaliException e) {
73667       {
73668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73669       };
73670     } catch (...) {
73671       {
73672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73673       };
73674     }
73675   }
73676
73677 }
73678
73679
73680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
73681   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73682   Dali::Vector3 *arg2 = 0 ;
73683
73684   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73685   arg2 = (Dali::Vector3 *)jarg2;
73686   if (!arg2) {
73687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73688     return ;
73689   }
73690   {
73691     try {
73692       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
73693     } catch (std::out_of_range& e) {
73694       {
73695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73696       };
73697     } catch (std::exception& e) {
73698       {
73699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73700       };
73701     } catch (Dali::DaliException e) {
73702       {
73703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73704       };
73705     } catch (...) {
73706       {
73707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73708       };
73709     }
73710   }
73711
73712 }
73713
73714
73715 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
73716   float jresult ;
73717   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73718   unsigned int arg2 ;
73719   Dali::Vector3 arg3 ;
73720   Dali::Vector3 *argp3 ;
73721   float result;
73722
73723   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73724   arg2 = (unsigned int)jarg2;
73725   argp3 = (Dali::Vector3 *)jarg3;
73726   if (!argp3) {
73727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73728     return 0;
73729   }
73730   arg3 = *argp3;
73731   {
73732     try {
73733       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
73734     } catch (std::out_of_range& e) {
73735       {
73736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73737       };
73738     } catch (std::exception& e) {
73739       {
73740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73741       };
73742     } catch (Dali::DaliException e) {
73743       {
73744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73745       };
73746     } catch (...) {
73747       {
73748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73749       };
73750     }
73751   }
73752
73753   jresult = result;
73754   return jresult;
73755 }
73756
73757
73758 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
73759   float jresult ;
73760   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73761   float arg2 ;
73762   float result;
73763
73764   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73765   arg2 = (float)jarg2;
73766   {
73767     try {
73768       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
73769     } catch (std::out_of_range& e) {
73770       {
73771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73772       };
73773     } catch (std::exception& e) {
73774       {
73775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73776       };
73777     } catch (Dali::DaliException e) {
73778       {
73779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73780       };
73781     } catch (...) {
73782       {
73783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73784       };
73785     }
73786   }
73787
73788   jresult = result;
73789   return jresult;
73790 }
73791
73792
73793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
73794   float jresult ;
73795   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73796   unsigned int arg2 ;
73797   float result;
73798
73799   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73800   arg2 = (unsigned int)jarg2;
73801   {
73802     try {
73803       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
73804     } catch (std::out_of_range& e) {
73805       {
73806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73807       };
73808     } catch (std::exception& e) {
73809       {
73810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73811       };
73812     } catch (Dali::DaliException e) {
73813       {
73814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73815       };
73816     } catch (...) {
73817       {
73818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73819       };
73820     }
73821   }
73822
73823   jresult = result;
73824   return jresult;
73825 }
73826
73827
73828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
73829   void * jresult ;
73830   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73831   float arg2 ;
73832   Dali::Vector3 arg3 ;
73833   Dali::Vector3 *argp3 ;
73834   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73835
73836   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73837   arg2 = (float)jarg2;
73838   argp3 = (Dali::Vector3 *)jarg3;
73839   if (!argp3) {
73840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73841     return 0;
73842   }
73843   arg3 = *argp3;
73844   {
73845     try {
73846       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
73847     } catch (std::out_of_range& e) {
73848       {
73849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73850       };
73851     } catch (std::exception& e) {
73852       {
73853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73854       };
73855     } catch (Dali::DaliException e) {
73856       {
73857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73858       };
73859     } catch (...) {
73860       {
73861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73862       };
73863     }
73864   }
73865
73866   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73867   return jresult;
73868 }
73869
73870
73871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
73872   float jresult ;
73873   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73874   int arg2 ;
73875   float arg3 ;
73876   Dali::Vector3 *arg4 = 0 ;
73877   float result;
73878
73879   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73880   arg2 = (int)jarg2;
73881   arg3 = (float)jarg3;
73882   arg4 = (Dali::Vector3 *)jarg4;
73883   if (!arg4) {
73884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73885     return 0;
73886   }
73887   {
73888     try {
73889       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
73890     } catch (std::out_of_range& e) {
73891       {
73892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73893       };
73894     } catch (std::exception& e) {
73895       {
73896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73897       };
73898     } catch (Dali::DaliException e) {
73899       {
73900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73901       };
73902     } catch (...) {
73903       {
73904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73905       };
73906     }
73907   }
73908
73909   jresult = result;
73910   return jresult;
73911 }
73912
73913
73914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
73915   unsigned int jresult ;
73916   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73917   Dali::Vector3 arg2 ;
73918   Dali::Vector3 *argp2 ;
73919   unsigned int result;
73920
73921   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73922   argp2 = (Dali::Vector3 *)jarg2;
73923   if (!argp2) {
73924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73925     return 0;
73926   }
73927   arg2 = *argp2;
73928   {
73929     try {
73930       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
73931     } catch (std::out_of_range& e) {
73932       {
73933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73934       };
73935     } catch (std::exception& e) {
73936       {
73937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73938       };
73939     } catch (Dali::DaliException e) {
73940       {
73941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73942       };
73943     } catch (...) {
73944       {
73945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73946       };
73947     }
73948   }
73949
73950   jresult = result;
73951   return jresult;
73952 }
73953
73954
73955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
73956   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73957   unsigned int arg2 ;
73958   Dali::Vector3 *arg3 = 0 ;
73959   Dali::Vector3 *arg4 = 0 ;
73960
73961   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73962   arg2 = (unsigned int)jarg2;
73963   arg3 = (Dali::Vector3 *)jarg3;
73964   if (!arg3) {
73965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73966     return ;
73967   }
73968   arg4 = (Dali::Vector3 *)jarg4;
73969   if (!arg4) {
73970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
73971     return ;
73972   }
73973   {
73974     try {
73975       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
73976     } catch (std::out_of_range& e) {
73977       {
73978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73979       };
73980     } catch (std::exception& e) {
73981       {
73982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73983       };
73984     } catch (Dali::DaliException e) {
73985       {
73986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73987       };
73988     } catch (...) {
73989       {
73990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73991       };
73992     }
73993   }
73994
73995 }
73996
73997
73998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
73999   void * jresult ;
74000   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74001   Dali::Degree result;
74002
74003   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74004   {
74005     try {
74006       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
74007     } catch (std::out_of_range& e) {
74008       {
74009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74010       };
74011     } catch (std::exception& e) {
74012       {
74013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74014       };
74015     } catch (Dali::DaliException e) {
74016       {
74017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74018       };
74019     } catch (...) {
74020       {
74021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74022       };
74023     }
74024   }
74025
74026   jresult = new Dali::Degree((const Dali::Degree &)result);
74027   return jresult;
74028 }
74029
74030
74031 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
74032   float jresult ;
74033   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74034   float result;
74035
74036   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74037   {
74038     try {
74039       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
74040     } catch (std::out_of_range& e) {
74041       {
74042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74043       };
74044     } catch (std::exception& e) {
74045       {
74046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74047       };
74048     } catch (Dali::DaliException e) {
74049       {
74050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74051       };
74052     } catch (...) {
74053       {
74054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74055       };
74056     }
74057   }
74058
74059   jresult = result;
74060   return jresult;
74061 }
74062
74063
74064 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
74065   float jresult ;
74066   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74067   float result;
74068
74069   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74070   {
74071     try {
74072       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
74073     } catch (std::out_of_range& e) {
74074       {
74075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74076       };
74077     } catch (std::exception& e) {
74078       {
74079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74080       };
74081     } catch (Dali::DaliException e) {
74082       {
74083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74084       };
74085     } catch (...) {
74086       {
74087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74088       };
74089     }
74090   }
74091
74092   jresult = result;
74093   return jresult;
74094 }
74095
74096
74097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
74098   float jresult ;
74099   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74100   float result;
74101
74102   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74103   {
74104     try {
74105       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
74106     } catch (std::out_of_range& e) {
74107       {
74108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74109       };
74110     } catch (std::exception& e) {
74111       {
74112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74113       };
74114     } catch (Dali::DaliException e) {
74115       {
74116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74117       };
74118     } catch (...) {
74119       {
74120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74121       };
74122     }
74123   }
74124
74125   jresult = result;
74126   return jresult;
74127 }
74128
74129
74130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
74131   int jresult ;
74132   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74133   int arg2 ;
74134   int arg3 ;
74135   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
74136   bool arg5 ;
74137   int result;
74138
74139   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74140   arg2 = (int)jarg2;
74141   arg3 = (int)jarg3;
74142   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
74143   arg5 = jarg5 ? true : false;
74144   {
74145     try {
74146       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
74147     } catch (std::out_of_range& e) {
74148       {
74149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74150       };
74151     } catch (std::exception& e) {
74152       {
74153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74154       };
74155     } catch (Dali::DaliException e) {
74156       {
74157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74158       };
74159     } catch (...) {
74160       {
74161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74162       };
74163     }
74164   }
74165
74166   jresult = result;
74167   return jresult;
74168 }
74169
74170
74171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
74172   float jresult ;
74173   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74174   float result;
74175
74176   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74177   {
74178     try {
74179       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
74180     } catch (std::out_of_range& e) {
74181       {
74182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74183       };
74184     } catch (std::exception& e) {
74185       {
74186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74187       };
74188     } catch (Dali::DaliException e) {
74189       {
74190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74191       };
74192     } catch (...) {
74193       {
74194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74195       };
74196     }
74197   }
74198
74199   jresult = result;
74200   return jresult;
74201 }
74202
74203
74204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
74205   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74206   Dali::Actor *arg2 = 0 ;
74207   int arg3 ;
74208   Dali::Vector3 *arg4 = 0 ;
74209   Dali::Actor *arg5 = 0 ;
74210
74211   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74212   arg2 = (Dali::Actor *)jarg2;
74213   if (!arg2) {
74214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74215     return ;
74216   }
74217   arg3 = (int)jarg3;
74218   arg4 = (Dali::Vector3 *)jarg4;
74219   if (!arg4) {
74220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74221     return ;
74222   }
74223   arg5 = (Dali::Actor *)jarg5;
74224   if (!arg5) {
74225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
74226     return ;
74227   }
74228   {
74229     try {
74230       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
74231     } catch (std::out_of_range& e) {
74232       {
74233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74234       };
74235     } catch (std::exception& e) {
74236       {
74237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74238       };
74239     } catch (Dali::DaliException e) {
74240       {
74241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74242       };
74243     } catch (...) {
74244       {
74245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74246       };
74247     }
74248   }
74249
74250 }
74251
74252
74253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
74254   void * jresult ;
74255   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74256   int arg2 ;
74257   float arg3 ;
74258   Dali::Vector3 *arg4 = 0 ;
74259   Dali::Vector3 result;
74260
74261   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74262   arg2 = (int)jarg2;
74263   arg3 = (float)jarg3;
74264   arg4 = (Dali::Vector3 *)jarg4;
74265   if (!arg4) {
74266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74267     return 0;
74268   }
74269   {
74270     try {
74271       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
74272     } catch (std::out_of_range& e) {
74273       {
74274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74275       };
74276     } catch (std::exception& e) {
74277       {
74278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74279       };
74280     } catch (Dali::DaliException e) {
74281       {
74282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74283       };
74284     } catch (...) {
74285       {
74286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74287       };
74288     }
74289   }
74290
74291   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
74292   return jresult;
74293 }
74294
74295
74296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
74297   void * jresult ;
74298   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
74299   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
74300
74301   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
74302   {
74303     try {
74304       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
74305     } catch (std::out_of_range& e) {
74306       {
74307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74308       };
74309     } catch (std::exception& e) {
74310       {
74311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74312       };
74313     } catch (Dali::DaliException e) {
74314       {
74315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74316       };
74317     } catch (...) {
74318       {
74319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74320       };
74321     }
74322   }
74323
74324   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
74325   return jresult;
74326 }
74327
74328
74329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
74330   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74331
74332   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74333   {
74334     try {
74335       delete arg1;
74336     } catch (std::out_of_range& e) {
74337       {
74338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74339       };
74340     } catch (std::exception& e) {
74341       {
74342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74343       };
74344     } catch (Dali::DaliException e) {
74345       {
74346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74347       };
74348     } catch (...) {
74349       {
74350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74351       };
74352     }
74353   }
74354
74355 }
74356
74357
74358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
74359   unsigned int jresult ;
74360   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74361   unsigned int result;
74362
74363   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74364   {
74365     try {
74366       result = (unsigned int)(arg1)->GetNumberOfItems();
74367     } catch (std::out_of_range& e) {
74368       {
74369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74370       };
74371     } catch (std::exception& e) {
74372       {
74373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74374       };
74375     } catch (Dali::DaliException e) {
74376       {
74377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74378       };
74379     } catch (...) {
74380       {
74381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74382       };
74383     }
74384   }
74385
74386   jresult = result;
74387   return jresult;
74388 }
74389
74390
74391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
74392   void * jresult ;
74393   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74394   unsigned int arg2 ;
74395   Dali::Actor result;
74396
74397   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74398   arg2 = (unsigned int)jarg2;
74399   {
74400     try {
74401       result = (arg1)->NewItem(arg2);
74402     } catch (std::out_of_range& e) {
74403       {
74404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74405       };
74406     } catch (std::exception& e) {
74407       {
74408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74409       };
74410     } catch (Dali::DaliException e) {
74411       {
74412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74413       };
74414     } catch (...) {
74415       {
74416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74417       };
74418     }
74419   }
74420
74421   jresult = new Dali::Actor((const Dali::Actor &)result);
74422   return jresult;
74423 }
74424
74425
74426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
74427   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74428   unsigned int arg2 ;
74429   Dali::Actor arg3 ;
74430   Dali::Actor *argp3 ;
74431
74432   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74433   arg2 = (unsigned int)jarg2;
74434   argp3 = (Dali::Actor *)jarg3;
74435   if (!argp3) {
74436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74437     return ;
74438   }
74439   arg3 = *argp3;
74440   {
74441     try {
74442       (arg1)->ItemReleased(arg2,arg3);
74443     } catch (std::out_of_range& e) {
74444       {
74445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74446       };
74447     } catch (std::exception& e) {
74448       {
74449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74450       };
74451     } catch (Dali::DaliException e) {
74452       {
74453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74454       };
74455     } catch (...) {
74456       {
74457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74458       };
74459     }
74460   }
74461
74462 }
74463
74464
74465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
74466   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74467   unsigned int arg2 ;
74468   Dali::Actor arg3 ;
74469   Dali::Actor *argp3 ;
74470
74471   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74472   arg2 = (unsigned int)jarg2;
74473   argp3 = (Dali::Actor *)jarg3;
74474   if (!argp3) {
74475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74476     return ;
74477   }
74478   arg3 = *argp3;
74479   {
74480     try {
74481       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
74482     } catch (std::out_of_range& e) {
74483       {
74484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74485       };
74486     } catch (std::exception& e) {
74487       {
74488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74489       };
74490     } catch (Dali::DaliException e) {
74491       {
74492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74493       };
74494     } catch (...) {
74495       {
74496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74497       };
74498     }
74499   }
74500
74501 }
74502
74503
74504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
74505   void * jresult ;
74506   Dali::Toolkit::ItemFactory *result = 0 ;
74507
74508   {
74509     try {
74510       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
74511     } catch (std::out_of_range& e) {
74512       {
74513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74514       };
74515     } catch (std::exception& e) {
74516       {
74517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74518       };
74519     } catch (Dali::DaliException e) {
74520       {
74521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74522       };
74523     } catch (...) {
74524       {
74525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74526       };
74527     }
74528   }
74529
74530   jresult = (void *)result;
74531   return jresult;
74532 }
74533
74534
74535 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) {
74536   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
74537   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
74538   if (director) {
74539     director->swig_connect_director(callback0, callback1, callback2);
74540   }
74541 }
74542
74543
74544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
74545   int jresult ;
74546   int result;
74547
74548   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
74549   jresult = (int)result;
74550   return jresult;
74551 }
74552
74553
74554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
74555   int jresult ;
74556   int result;
74557
74558   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
74559   jresult = (int)result;
74560   return jresult;
74561 }
74562
74563
74564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74565   int jresult ;
74566   int result;
74567
74568   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74569   jresult = (int)result;
74570   return jresult;
74571 }
74572
74573
74574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
74575   int jresult ;
74576   int result;
74577
74578   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
74579   jresult = (int)result;
74580   return jresult;
74581 }
74582
74583
74584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
74585   int jresult ;
74586   int result;
74587
74588   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
74589   jresult = (int)result;
74590   return jresult;
74591 }
74592
74593
74594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
74595   int jresult ;
74596   int result;
74597
74598   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
74599   jresult = (int)result;
74600   return jresult;
74601 }
74602
74603
74604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
74605   int jresult ;
74606   int result;
74607
74608   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
74609   jresult = (int)result;
74610   return jresult;
74611 }
74612
74613
74614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
74615   int jresult ;
74616   int result;
74617
74618   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
74619   jresult = (int)result;
74620   return jresult;
74621 }
74622
74623
74624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
74625   int jresult ;
74626   int result;
74627
74628   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
74629   jresult = (int)result;
74630   return jresult;
74631 }
74632
74633
74634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
74635   int jresult ;
74636   int result;
74637
74638   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
74639   jresult = (int)result;
74640   return jresult;
74641 }
74642
74643
74644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
74645   int jresult ;
74646   int result;
74647
74648   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
74649   jresult = (int)result;
74650   return jresult;
74651 }
74652
74653
74654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
74655   void * jresult ;
74656   Dali::Toolkit::ItemView::Property *result = 0 ;
74657
74658   {
74659     try {
74660       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
74661     } catch (std::out_of_range& e) {
74662       {
74663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74664       };
74665     } catch (std::exception& e) {
74666       {
74667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74668       };
74669     } catch (Dali::DaliException e) {
74670       {
74671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74672       };
74673     } catch (...) {
74674       {
74675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74676       };
74677     }
74678   }
74679
74680   jresult = (void *)result;
74681   return jresult;
74682 }
74683
74684
74685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
74686   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
74687
74688   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
74689   {
74690     try {
74691       delete arg1;
74692     } catch (std::out_of_range& e) {
74693       {
74694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74695       };
74696     } catch (std::exception& e) {
74697       {
74698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74699       };
74700     } catch (Dali::DaliException e) {
74701       {
74702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74703       };
74704     } catch (...) {
74705       {
74706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74707       };
74708     }
74709   }
74710
74711 }
74712
74713
74714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
74715   void * jresult ;
74716   Dali::Toolkit::ItemView *result = 0 ;
74717
74718   {
74719     try {
74720       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
74721     } catch (std::out_of_range& e) {
74722       {
74723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74724       };
74725     } catch (std::exception& e) {
74726       {
74727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74728       };
74729     } catch (Dali::DaliException e) {
74730       {
74731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74732       };
74733     } catch (...) {
74734       {
74735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74736       };
74737     }
74738   }
74739
74740   jresult = (void *)result;
74741   return jresult;
74742 }
74743
74744
74745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
74746   void * jresult ;
74747   Dali::Toolkit::ItemView *arg1 = 0 ;
74748   Dali::Toolkit::ItemView *result = 0 ;
74749
74750   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74751   if (!arg1) {
74752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74753     return 0;
74754   }
74755   {
74756     try {
74757       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
74758     } catch (std::out_of_range& e) {
74759       {
74760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74761       };
74762     } catch (std::exception& e) {
74763       {
74764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74765       };
74766     } catch (Dali::DaliException e) {
74767       {
74768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74769       };
74770     } catch (...) {
74771       {
74772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74773       };
74774     }
74775   }
74776
74777   jresult = (void *)result;
74778   return jresult;
74779 }
74780
74781
74782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
74783   void * jresult ;
74784   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74785   Dali::Toolkit::ItemView *arg2 = 0 ;
74786   Dali::Toolkit::ItemView *result = 0 ;
74787
74788   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74789   arg2 = (Dali::Toolkit::ItemView *)jarg2;
74790   if (!arg2) {
74791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74792     return 0;
74793   }
74794   {
74795     try {
74796       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
74797     } catch (std::out_of_range& e) {
74798       {
74799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74800       };
74801     } catch (std::exception& e) {
74802       {
74803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74804       };
74805     } catch (Dali::DaliException e) {
74806       {
74807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74808       };
74809     } catch (...) {
74810       {
74811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74812       };
74813     }
74814   }
74815
74816   jresult = (void *)result;
74817   return jresult;
74818 }
74819
74820
74821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
74822   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74823
74824   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74825   {
74826     try {
74827       delete arg1;
74828     } catch (std::out_of_range& e) {
74829       {
74830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74831       };
74832     } catch (std::exception& e) {
74833       {
74834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74835       };
74836     } catch (Dali::DaliException e) {
74837       {
74838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74839       };
74840     } catch (...) {
74841       {
74842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74843       };
74844     }
74845   }
74846
74847 }
74848
74849
74850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
74851   void * jresult ;
74852   Dali::Toolkit::ItemFactory *arg1 = 0 ;
74853   Dali::Toolkit::ItemView result;
74854
74855   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74856   if (!arg1) {
74857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
74858     return 0;
74859   }
74860   {
74861     try {
74862       result = Dali::Toolkit::ItemView::New(*arg1);
74863     } catch (std::out_of_range& e) {
74864       {
74865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74866       };
74867     } catch (std::exception& e) {
74868       {
74869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74870       };
74871     } catch (Dali::DaliException e) {
74872       {
74873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74874       };
74875     } catch (...) {
74876       {
74877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74878       };
74879     }
74880   }
74881
74882   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
74883   return jresult;
74884 }
74885
74886
74887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
74888   void * jresult ;
74889   Dali::BaseHandle arg1 ;
74890   Dali::BaseHandle *argp1 ;
74891   Dali::Toolkit::ItemView result;
74892
74893   argp1 = (Dali::BaseHandle *)jarg1;
74894   if (!argp1) {
74895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74896     return 0;
74897   }
74898   arg1 = *argp1;
74899   {
74900     try {
74901       result = Dali::Toolkit::ItemView::DownCast(arg1);
74902     } catch (std::out_of_range& e) {
74903       {
74904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74905       };
74906     } catch (std::exception& e) {
74907       {
74908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74909       };
74910     } catch (Dali::DaliException e) {
74911       {
74912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74913       };
74914     } catch (...) {
74915       {
74916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74917       };
74918     }
74919   }
74920
74921   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
74922   return jresult;
74923 }
74924
74925
74926 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
74927   unsigned int jresult ;
74928   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74929   unsigned int result;
74930
74931   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74932   {
74933     try {
74934       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
74935     } catch (std::out_of_range& e) {
74936       {
74937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74938       };
74939     } catch (std::exception& e) {
74940       {
74941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74942       };
74943     } catch (Dali::DaliException e) {
74944       {
74945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74946       };
74947     } catch (...) {
74948       {
74949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74950       };
74951     }
74952   }
74953
74954   jresult = result;
74955   return jresult;
74956 }
74957
74958
74959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
74960   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74961   Dali::Toolkit::ItemLayout *arg2 = 0 ;
74962
74963   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74964   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
74965   if (!arg2) {
74966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
74967     return ;
74968   }
74969   {
74970     try {
74971       (arg1)->AddLayout(*arg2);
74972     } catch (std::out_of_range& e) {
74973       {
74974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74975       };
74976     } catch (std::exception& e) {
74977       {
74978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74979       };
74980     } catch (Dali::DaliException e) {
74981       {
74982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74983       };
74984     } catch (...) {
74985       {
74986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74987       };
74988     }
74989   }
74990
74991 }
74992
74993
74994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
74995   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74996   unsigned int arg2 ;
74997
74998   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74999   arg2 = (unsigned int)jarg2;
75000   {
75001     try {
75002       (arg1)->RemoveLayout(arg2);
75003     } catch (std::out_of_range& e) {
75004       {
75005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75006       };
75007     } catch (std::exception& e) {
75008       {
75009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75010       };
75011     } catch (Dali::DaliException e) {
75012       {
75013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75014       };
75015     } catch (...) {
75016       {
75017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75018       };
75019     }
75020   }
75021
75022 }
75023
75024
75025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
75026   void * jresult ;
75027   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75028   unsigned int arg2 ;
75029   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75030
75031   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75032   arg2 = (unsigned int)jarg2;
75033   {
75034     try {
75035       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
75036     } catch (std::out_of_range& e) {
75037       {
75038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75039       };
75040     } catch (std::exception& e) {
75041       {
75042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75043       };
75044     } catch (Dali::DaliException e) {
75045       {
75046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75047       };
75048     } catch (...) {
75049       {
75050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75051       };
75052     }
75053   }
75054
75055   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75056   return jresult;
75057 }
75058
75059
75060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
75061   void * jresult ;
75062   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75063   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75064
75065   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75066   {
75067     try {
75068       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
75069     } catch (std::out_of_range& e) {
75070       {
75071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75072       };
75073     } catch (std::exception& e) {
75074       {
75075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75076       };
75077     } catch (Dali::DaliException e) {
75078       {
75079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75080       };
75081     } catch (...) {
75082       {
75083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75084       };
75085     }
75086   }
75087
75088   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75089   return jresult;
75090 }
75091
75092
75093 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
75094   float jresult ;
75095   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75096   Dali::Toolkit::ItemId arg2 ;
75097   float result;
75098
75099   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75100   arg2 = (Dali::Toolkit::ItemId)jarg2;
75101   {
75102     try {
75103       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
75104     } catch (std::out_of_range& e) {
75105       {
75106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75107       };
75108     } catch (std::exception& e) {
75109       {
75110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75111       };
75112     } catch (Dali::DaliException e) {
75113       {
75114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75115       };
75116     } catch (...) {
75117       {
75118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75119       };
75120     }
75121   }
75122
75123   jresult = result;
75124   return jresult;
75125 }
75126
75127
75128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
75129   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75130   unsigned int arg2 ;
75131   Dali::Vector3 arg3 ;
75132   float arg4 ;
75133   Dali::Vector3 *argp3 ;
75134
75135   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75136   arg2 = (unsigned int)jarg2;
75137   argp3 = (Dali::Vector3 *)jarg3;
75138   if (!argp3) {
75139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75140     return ;
75141   }
75142   arg3 = *argp3;
75143   arg4 = (float)jarg4;
75144   {
75145     try {
75146       (arg1)->ActivateLayout(arg2,arg3,arg4);
75147     } catch (std::out_of_range& e) {
75148       {
75149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75150       };
75151     } catch (std::exception& e) {
75152       {
75153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75154       };
75155     } catch (Dali::DaliException e) {
75156       {
75157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75158       };
75159     } catch (...) {
75160       {
75161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75162       };
75163     }
75164   }
75165
75166 }
75167
75168
75169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
75170   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75171
75172   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75173   {
75174     try {
75175       (arg1)->DeactivateCurrentLayout();
75176     } catch (std::out_of_range& e) {
75177       {
75178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75179       };
75180     } catch (std::exception& e) {
75181       {
75182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75183       };
75184     } catch (Dali::DaliException e) {
75185       {
75186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75187       };
75188     } catch (...) {
75189       {
75190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75191       };
75192     }
75193   }
75194
75195 }
75196
75197
75198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
75199   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75200   float arg2 ;
75201
75202   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75203   arg2 = (float)jarg2;
75204   {
75205     try {
75206       (arg1)->SetMinimumSwipeSpeed(arg2);
75207     } catch (std::out_of_range& e) {
75208       {
75209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75210       };
75211     } catch (std::exception& e) {
75212       {
75213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75214       };
75215     } catch (Dali::DaliException e) {
75216       {
75217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75218       };
75219     } catch (...) {
75220       {
75221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75222       };
75223     }
75224   }
75225
75226 }
75227
75228
75229 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
75230   float jresult ;
75231   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75232   float result;
75233
75234   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75235   {
75236     try {
75237       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
75238     } catch (std::out_of_range& e) {
75239       {
75240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75241       };
75242     } catch (std::exception& e) {
75243       {
75244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75245       };
75246     } catch (Dali::DaliException e) {
75247       {
75248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75249       };
75250     } catch (...) {
75251       {
75252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75253       };
75254     }
75255   }
75256
75257   jresult = result;
75258   return jresult;
75259 }
75260
75261
75262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
75263   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75264   float arg2 ;
75265
75266   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75267   arg2 = (float)jarg2;
75268   {
75269     try {
75270       (arg1)->SetMinimumSwipeDistance(arg2);
75271     } catch (std::out_of_range& e) {
75272       {
75273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75274       };
75275     } catch (std::exception& e) {
75276       {
75277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75278       };
75279     } catch (Dali::DaliException e) {
75280       {
75281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75282       };
75283     } catch (...) {
75284       {
75285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75286       };
75287     }
75288   }
75289
75290 }
75291
75292
75293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
75294   float jresult ;
75295   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75296   float result;
75297
75298   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75299   {
75300     try {
75301       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
75302     } catch (std::out_of_range& e) {
75303       {
75304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75305       };
75306     } catch (std::exception& e) {
75307       {
75308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75309       };
75310     } catch (Dali::DaliException e) {
75311       {
75312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75313       };
75314     } catch (...) {
75315       {
75316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75317       };
75318     }
75319   }
75320
75321   jresult = result;
75322   return jresult;
75323 }
75324
75325
75326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
75327   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75328   float arg2 ;
75329
75330   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75331   arg2 = (float)jarg2;
75332   {
75333     try {
75334       (arg1)->SetWheelScrollDistanceStep(arg2);
75335     } catch (std::out_of_range& e) {
75336       {
75337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75338       };
75339     } catch (std::exception& e) {
75340       {
75341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75342       };
75343     } catch (Dali::DaliException e) {
75344       {
75345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75346       };
75347     } catch (...) {
75348       {
75349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75350       };
75351     }
75352   }
75353
75354 }
75355
75356
75357 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
75358   float jresult ;
75359   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75360   float result;
75361
75362   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75363   {
75364     try {
75365       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
75366     } catch (std::out_of_range& e) {
75367       {
75368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75369       };
75370     } catch (std::exception& e) {
75371       {
75372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75373       };
75374     } catch (Dali::DaliException e) {
75375       {
75376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75377       };
75378     } catch (...) {
75379       {
75380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75381       };
75382     }
75383   }
75384
75385   jresult = result;
75386   return jresult;
75387 }
75388
75389
75390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
75391   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75392   bool arg2 ;
75393
75394   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75395   arg2 = jarg2 ? true : false;
75396   {
75397     try {
75398       (arg1)->SetAnchoring(arg2);
75399     } catch (std::out_of_range& e) {
75400       {
75401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75402       };
75403     } catch (std::exception& e) {
75404       {
75405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75406       };
75407     } catch (Dali::DaliException e) {
75408       {
75409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75410       };
75411     } catch (...) {
75412       {
75413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75414       };
75415     }
75416   }
75417
75418 }
75419
75420 //// ========================= end of part 3 =============================
75421
75422 //// ========================== start part 4 ===============================
75423
75424
75425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
75426   unsigned int jresult ;
75427   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75428   bool result;
75429
75430   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75431   {
75432     try {
75433       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
75434     } catch (std::out_of_range& e) {
75435       {
75436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75437       };
75438     } catch (std::exception& e) {
75439       {
75440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75441       };
75442     } catch (Dali::DaliException e) {
75443       {
75444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75445       };
75446     } catch (...) {
75447       {
75448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75449       };
75450     }
75451   }
75452
75453   jresult = result;
75454   return jresult;
75455 }
75456
75457
75458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
75459   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75460   float arg2 ;
75461
75462   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75463   arg2 = (float)jarg2;
75464   {
75465     try {
75466       (arg1)->SetAnchoringDuration(arg2);
75467     } catch (std::out_of_range& e) {
75468       {
75469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75470       };
75471     } catch (std::exception& e) {
75472       {
75473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75474       };
75475     } catch (Dali::DaliException e) {
75476       {
75477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75478       };
75479     } catch (...) {
75480       {
75481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75482       };
75483     }
75484   }
75485
75486 }
75487
75488
75489 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
75490   float jresult ;
75491   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75492   float result;
75493
75494   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75495   {
75496     try {
75497       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
75498     } catch (std::out_of_range& e) {
75499       {
75500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75501       };
75502     } catch (std::exception& e) {
75503       {
75504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75505       };
75506     } catch (Dali::DaliException e) {
75507       {
75508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75509       };
75510     } catch (...) {
75511       {
75512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75513       };
75514     }
75515   }
75516
75517   jresult = result;
75518   return jresult;
75519 }
75520
75521
75522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
75523   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75524   Dali::Toolkit::ItemId arg2 ;
75525   float arg3 ;
75526
75527   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75528   arg2 = (Dali::Toolkit::ItemId)jarg2;
75529   arg3 = (float)jarg3;
75530   {
75531     try {
75532       (arg1)->ScrollToItem(arg2,arg3);
75533     } catch (std::out_of_range& e) {
75534       {
75535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75536       };
75537     } catch (std::exception& e) {
75538       {
75539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75540       };
75541     } catch (Dali::DaliException e) {
75542       {
75543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75544       };
75545     } catch (...) {
75546       {
75547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75548       };
75549     }
75550   }
75551
75552 }
75553
75554
75555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
75556   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75557   float arg2 ;
75558
75559   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75560   arg2 = (float)jarg2;
75561   {
75562     try {
75563       (arg1)->SetRefreshInterval(arg2);
75564     } catch (std::out_of_range& e) {
75565       {
75566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75567       };
75568     } catch (std::exception& e) {
75569       {
75570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75571       };
75572     } catch (Dali::DaliException e) {
75573       {
75574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75575       };
75576     } catch (...) {
75577       {
75578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75579       };
75580     }
75581   }
75582
75583 }
75584
75585
75586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
75587   float jresult ;
75588   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75589   float result;
75590
75591   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75592   {
75593     try {
75594       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
75595     } catch (std::out_of_range& e) {
75596       {
75597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75598       };
75599     } catch (std::exception& e) {
75600       {
75601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75602       };
75603     } catch (Dali::DaliException e) {
75604       {
75605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75606       };
75607     } catch (...) {
75608       {
75609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75610       };
75611     }
75612   }
75613
75614   jresult = result;
75615   return jresult;
75616 }
75617
75618
75619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
75620   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75621
75622   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75623   {
75624     try {
75625       (arg1)->Refresh();
75626     } catch (std::out_of_range& e) {
75627       {
75628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75629       };
75630     } catch (std::exception& e) {
75631       {
75632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75633       };
75634     } catch (Dali::DaliException e) {
75635       {
75636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75637       };
75638     } catch (...) {
75639       {
75640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75641       };
75642     }
75643   }
75644
75645 }
75646
75647
75648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
75649   void * jresult ;
75650   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75651   Dali::Toolkit::ItemId arg2 ;
75652   Dali::Actor result;
75653
75654   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75655   arg2 = (Dali::Toolkit::ItemId)jarg2;
75656   {
75657     try {
75658       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
75659     } catch (std::out_of_range& e) {
75660       {
75661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75662       };
75663     } catch (std::exception& e) {
75664       {
75665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75666       };
75667     } catch (Dali::DaliException e) {
75668       {
75669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75670       };
75671     } catch (...) {
75672       {
75673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75674       };
75675     }
75676   }
75677
75678   jresult = new Dali::Actor((const Dali::Actor &)result);
75679   return jresult;
75680 }
75681
75682
75683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
75684   unsigned int jresult ;
75685   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75686   Dali::Actor arg2 ;
75687   Dali::Actor *argp2 ;
75688   Dali::Toolkit::ItemId result;
75689
75690   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75691   argp2 = (Dali::Actor *)jarg2;
75692   if (!argp2) {
75693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75694     return 0;
75695   }
75696   arg2 = *argp2;
75697   {
75698     try {
75699       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
75700     } catch (std::out_of_range& e) {
75701       {
75702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75703       };
75704     } catch (std::exception& e) {
75705       {
75706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75707       };
75708     } catch (Dali::DaliException e) {
75709       {
75710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75711       };
75712     } catch (...) {
75713       {
75714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75715       };
75716     }
75717   }
75718
75719   jresult = result;
75720   return jresult;
75721 }
75722
75723
75724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
75725   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75726   Dali::Toolkit::Item arg2 ;
75727   float arg3 ;
75728   Dali::Toolkit::Item *argp2 ;
75729
75730   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75731   argp2 = (Dali::Toolkit::Item *)jarg2;
75732   if (!argp2) {
75733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75734     return ;
75735   }
75736   arg2 = *argp2;
75737   arg3 = (float)jarg3;
75738   {
75739     try {
75740       (arg1)->InsertItem(arg2,arg3);
75741     } catch (std::out_of_range& e) {
75742       {
75743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75744       };
75745     } catch (std::exception& e) {
75746       {
75747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75748       };
75749     } catch (Dali::DaliException e) {
75750       {
75751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75752       };
75753     } catch (...) {
75754       {
75755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75756       };
75757     }
75758   }
75759
75760 }
75761
75762
75763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
75764   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75765   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75766   float arg3 ;
75767
75768   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75769   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
75770   if (!arg2) {
75771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
75772     return ;
75773   }
75774   arg3 = (float)jarg3;
75775   {
75776     try {
75777       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
75778     } catch (std::out_of_range& e) {
75779       {
75780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75781       };
75782     } catch (std::exception& e) {
75783       {
75784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75785       };
75786     } catch (Dali::DaliException e) {
75787       {
75788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75789       };
75790     } catch (...) {
75791       {
75792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75793       };
75794     }
75795   }
75796
75797 }
75798
75799
75800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
75801   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75802   Dali::Toolkit::ItemId arg2 ;
75803   float arg3 ;
75804
75805   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75806   arg2 = (Dali::Toolkit::ItemId)jarg2;
75807   arg3 = (float)jarg3;
75808   {
75809     try {
75810       (arg1)->RemoveItem(arg2,arg3);
75811     } catch (std::out_of_range& e) {
75812       {
75813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75814       };
75815     } catch (std::exception& e) {
75816       {
75817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75818       };
75819     } catch (Dali::DaliException e) {
75820       {
75821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75822       };
75823     } catch (...) {
75824       {
75825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75826       };
75827     }
75828   }
75829
75830 }
75831
75832
75833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
75834   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75835   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
75836   float arg3 ;
75837
75838   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75839   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
75840   if (!arg2) {
75841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
75842     return ;
75843   }
75844   arg3 = (float)jarg3;
75845   {
75846     try {
75847       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
75848     } catch (std::out_of_range& e) {
75849       {
75850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75851       };
75852     } catch (std::exception& e) {
75853       {
75854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75855       };
75856     } catch (Dali::DaliException e) {
75857       {
75858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75859       };
75860     } catch (...) {
75861       {
75862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75863       };
75864     }
75865   }
75866
75867 }
75868
75869
75870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
75871   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75872   Dali::Toolkit::Item arg2 ;
75873   float arg3 ;
75874   Dali::Toolkit::Item *argp2 ;
75875
75876   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75877   argp2 = (Dali::Toolkit::Item *)jarg2;
75878   if (!argp2) {
75879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75880     return ;
75881   }
75882   arg2 = *argp2;
75883   arg3 = (float)jarg3;
75884   {
75885     try {
75886       (arg1)->ReplaceItem(arg2,arg3);
75887     } catch (std::out_of_range& e) {
75888       {
75889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75890       };
75891     } catch (std::exception& e) {
75892       {
75893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75894       };
75895     } catch (Dali::DaliException e) {
75896       {
75897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75898       };
75899     } catch (...) {
75900       {
75901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75902       };
75903     }
75904   }
75905
75906 }
75907
75908
75909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
75910   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75911   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75912   float arg3 ;
75913
75914   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75915   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
75916   if (!arg2) {
75917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
75918     return ;
75919   }
75920   arg3 = (float)jarg3;
75921   {
75922     try {
75923       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
75924     } catch (std::out_of_range& e) {
75925       {
75926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75927       };
75928     } catch (std::exception& e) {
75929       {
75930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75931       };
75932     } catch (Dali::DaliException e) {
75933       {
75934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75935       };
75936     } catch (...) {
75937       {
75938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75939       };
75940     }
75941   }
75942
75943 }
75944
75945
75946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
75947   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75948   Dali::Vector3 *arg2 = 0 ;
75949
75950   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75951   arg2 = (Dali::Vector3 *)jarg2;
75952   if (!arg2) {
75953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75954     return ;
75955   }
75956   {
75957     try {
75958       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
75959     } catch (std::out_of_range& e) {
75960       {
75961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75962       };
75963     } catch (std::exception& e) {
75964       {
75965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75966       };
75967     } catch (Dali::DaliException e) {
75968       {
75969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75970       };
75971     } catch (...) {
75972       {
75973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75974       };
75975     }
75976   }
75977
75978 }
75979
75980
75981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
75982   void * jresult ;
75983   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75984   Dali::Vector3 result;
75985
75986   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75987   {
75988     try {
75989       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
75990     } catch (std::out_of_range& e) {
75991       {
75992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75993       };
75994     } catch (std::exception& e) {
75995       {
75996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75997       };
75998     } catch (Dali::DaliException e) {
75999       {
76000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76001       };
76002     } catch (...) {
76003       {
76004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76005       };
76006     }
76007   }
76008
76009   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76010   return jresult;
76011 }
76012
76013
76014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
76015   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76016   Dali::Vector3 *arg2 = 0 ;
76017
76018   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76019   arg2 = (Dali::Vector3 *)jarg2;
76020   if (!arg2) {
76021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76022     return ;
76023   }
76024   {
76025     try {
76026       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
76027     } catch (std::out_of_range& e) {
76028       {
76029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76030       };
76031     } catch (std::exception& e) {
76032       {
76033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76034       };
76035     } catch (Dali::DaliException e) {
76036       {
76037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76038       };
76039     } catch (...) {
76040       {
76041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76042       };
76043     }
76044   }
76045
76046 }
76047
76048
76049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
76050   void * jresult ;
76051   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76052   Dali::Vector3 result;
76053
76054   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76055   {
76056     try {
76057       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
76058     } catch (std::out_of_range& e) {
76059       {
76060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76061       };
76062     } catch (std::exception& e) {
76063       {
76064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76065       };
76066     } catch (Dali::DaliException e) {
76067       {
76068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76069       };
76070     } catch (...) {
76071       {
76072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76073       };
76074     }
76075   }
76076
76077   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76078   return jresult;
76079 }
76080
76081
76082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
76083   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76084   Dali::Toolkit::ItemRange *arg2 = 0 ;
76085
76086   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76087   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
76088   if (!arg2) {
76089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
76090     return ;
76091   }
76092   {
76093     try {
76094       (arg1)->GetItemsRange(*arg2);
76095     } catch (std::out_of_range& e) {
76096       {
76097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76098       };
76099     } catch (std::exception& e) {
76100       {
76101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76102       };
76103     } catch (Dali::DaliException e) {
76104       {
76105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76106       };
76107     } catch (...) {
76108       {
76109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76110       };
76111     }
76112   }
76113
76114 }
76115
76116
76117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
76118   void * jresult ;
76119   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76120   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
76121
76122   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76123   {
76124     try {
76125       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
76126     } catch (std::out_of_range& e) {
76127       {
76128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76129       };
76130     } catch (std::exception& e) {
76131       {
76132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76133       };
76134     } catch (Dali::DaliException e) {
76135       {
76136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76137       };
76138     } catch (...) {
76139       {
76140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76141       };
76142     }
76143   }
76144
76145   jresult = (void *)result;
76146   return jresult;
76147 }
76148
76149
76150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
76151   Dali::Vector3 *arg1 = 0 ;
76152   PropertyInputContainer *arg2 = 0 ;
76153
76154   arg1 = (Dali::Vector3 *)jarg1;
76155   if (!arg1) {
76156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
76157     return ;
76158   }
76159   arg2 = (PropertyInputContainer *)jarg2;
76160   if (!arg2) {
76161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
76162     return ;
76163   }
76164   {
76165     try {
76166       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
76167     } catch (std::out_of_range& e) {
76168       {
76169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76170       };
76171     } catch (std::exception& e) {
76172       {
76173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76174       };
76175     } catch (Dali::DaliException e) {
76176       {
76177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76178       };
76179     } catch (...) {
76180       {
76181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76182       };
76183     }
76184   }
76185
76186 }
76187
76188
76189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
76190   Dali::Vector3 *arg1 = 0 ;
76191   PropertyInputContainer *arg2 = 0 ;
76192
76193   arg1 = (Dali::Vector3 *)jarg1;
76194   if (!arg1) {
76195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
76196     return ;
76197   }
76198   arg2 = (PropertyInputContainer *)jarg2;
76199   if (!arg2) {
76200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
76201     return ;
76202   }
76203   {
76204     try {
76205       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
76206     } catch (std::out_of_range& e) {
76207       {
76208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76209       };
76210     } catch (std::exception& e) {
76211       {
76212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76213       };
76214     } catch (Dali::DaliException e) {
76215       {
76216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76217       };
76218     } catch (...) {
76219       {
76220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76221       };
76222     }
76223   }
76224
76225 }
76226
76227
76228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
76229   void * jresult ;
76230   Dali::Toolkit::ScrollViewEffect *result = 0 ;
76231
76232   {
76233     try {
76234       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
76235     } catch (std::out_of_range& e) {
76236       {
76237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76238       };
76239     } catch (std::exception& e) {
76240       {
76241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76242       };
76243     } catch (Dali::DaliException e) {
76244       {
76245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76246       };
76247     } catch (...) {
76248       {
76249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76250       };
76251     }
76252   }
76253
76254   jresult = (void *)result;
76255   return jresult;
76256 }
76257
76258
76259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
76260   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
76261
76262   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
76263   {
76264     try {
76265       delete arg1;
76266     } catch (std::out_of_range& e) {
76267       {
76268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76269       };
76270     } catch (std::exception& e) {
76271       {
76272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76273       };
76274     } catch (Dali::DaliException e) {
76275       {
76276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76277       };
76278     } catch (...) {
76279       {
76280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76281       };
76282     }
76283   }
76284
76285 }
76286
76287
76288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
76289   void * jresult ;
76290   Dali::Path arg1 ;
76291   Dali::Vector3 *arg2 = 0 ;
76292   Dali::Property::Index arg3 ;
76293   Dali::Vector3 *arg4 = 0 ;
76294   unsigned int arg5 ;
76295   Dali::Path *argp1 ;
76296   Dali::Toolkit::ScrollViewPagePathEffect result;
76297
76298   argp1 = (Dali::Path *)jarg1;
76299   if (!argp1) {
76300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
76301     return 0;
76302   }
76303   arg1 = *argp1;
76304   arg2 = (Dali::Vector3 *)jarg2;
76305   if (!arg2) {
76306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76307     return 0;
76308   }
76309   arg3 = (Dali::Property::Index)jarg3;
76310   arg4 = (Dali::Vector3 *)jarg4;
76311   if (!arg4) {
76312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76313     return 0;
76314   }
76315   arg5 = (unsigned int)jarg5;
76316   {
76317     try {
76318       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
76319     } catch (std::out_of_range& e) {
76320       {
76321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76322       };
76323     } catch (std::exception& e) {
76324       {
76325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76326       };
76327     } catch (Dali::DaliException e) {
76328       {
76329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76330       };
76331     } catch (...) {
76332       {
76333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76334       };
76335     }
76336   }
76337
76338   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76339   return jresult;
76340 }
76341
76342
76343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
76344   void * jresult ;
76345   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
76346
76347   {
76348     try {
76349       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
76350     } catch (std::out_of_range& e) {
76351       {
76352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76353       };
76354     } catch (std::exception& e) {
76355       {
76356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76357       };
76358     } catch (Dali::DaliException e) {
76359       {
76360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76361       };
76362     } catch (...) {
76363       {
76364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76365       };
76366     }
76367   }
76368
76369   jresult = (void *)result;
76370   return jresult;
76371 }
76372
76373
76374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
76375   void * jresult ;
76376   Dali::BaseHandle arg1 ;
76377   Dali::BaseHandle *argp1 ;
76378   Dali::Toolkit::ScrollViewPagePathEffect result;
76379
76380   argp1 = (Dali::BaseHandle *)jarg1;
76381   if (!argp1) {
76382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76383     return 0;
76384   }
76385   arg1 = *argp1;
76386   {
76387     try {
76388       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
76389     } catch (std::out_of_range& e) {
76390       {
76391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76392       };
76393     } catch (std::exception& e) {
76394       {
76395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76396       };
76397     } catch (Dali::DaliException e) {
76398       {
76399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76400       };
76401     } catch (...) {
76402       {
76403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76404       };
76405     }
76406   }
76407
76408   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76409   return jresult;
76410 }
76411
76412
76413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
76414   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76415   Dali::Actor arg2 ;
76416   unsigned int arg3 ;
76417   Dali::Actor *argp2 ;
76418
76419   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76420   argp2 = (Dali::Actor *)jarg2;
76421   if (!argp2) {
76422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76423     return ;
76424   }
76425   arg2 = *argp2;
76426   arg3 = (unsigned int)jarg3;
76427   {
76428     try {
76429       (arg1)->ApplyToPage(arg2,arg3);
76430     } catch (std::out_of_range& e) {
76431       {
76432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76433       };
76434     } catch (std::exception& e) {
76435       {
76436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76437       };
76438     } catch (Dali::DaliException e) {
76439       {
76440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76441       };
76442     } catch (...) {
76443       {
76444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76445       };
76446     }
76447   }
76448
76449 }
76450
76451
76452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
76453   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76454
76455   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76456   {
76457     try {
76458       delete arg1;
76459     } catch (std::out_of_range& e) {
76460       {
76461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76462       };
76463     } catch (std::exception& e) {
76464       {
76465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76466       };
76467     } catch (Dali::DaliException e) {
76468       {
76469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76470       };
76471     } catch (...) {
76472       {
76473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76474       };
76475     }
76476   }
76477
76478 }
76479
76480
76481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
76482   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76483   Dali::Toolkit::ClampState arg2 ;
76484
76485   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76486   arg2 = (Dali::Toolkit::ClampState)jarg2;
76487   if (arg1) (arg1)->x = arg2;
76488 }
76489
76490
76491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
76492   int jresult ;
76493   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76494   Dali::Toolkit::ClampState result;
76495
76496   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76497   result = (Dali::Toolkit::ClampState) ((arg1)->x);
76498   jresult = (int)result;
76499   return jresult;
76500 }
76501
76502
76503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
76504   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76505   Dali::Toolkit::ClampState arg2 ;
76506
76507   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76508   arg2 = (Dali::Toolkit::ClampState)jarg2;
76509   if (arg1) (arg1)->y = arg2;
76510 }
76511
76512
76513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
76514   int jresult ;
76515   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76516   Dali::Toolkit::ClampState result;
76517
76518   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76519   result = (Dali::Toolkit::ClampState) ((arg1)->y);
76520   jresult = (int)result;
76521   return jresult;
76522 }
76523
76524
76525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
76526   void * jresult ;
76527   Dali::Toolkit::ClampState2D *result = 0 ;
76528
76529   {
76530     try {
76531       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
76532     } catch (std::out_of_range& e) {
76533       {
76534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76535       };
76536     } catch (std::exception& e) {
76537       {
76538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76539       };
76540     } catch (Dali::DaliException e) {
76541       {
76542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76543       };
76544     } catch (...) {
76545       {
76546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76547       };
76548     }
76549   }
76550
76551   jresult = (void *)result;
76552   return jresult;
76553 }
76554
76555
76556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
76557   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76558
76559   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76560   {
76561     try {
76562       delete arg1;
76563     } catch (std::out_of_range& e) {
76564       {
76565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76566       };
76567     } catch (std::exception& e) {
76568       {
76569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76570       };
76571     } catch (Dali::DaliException e) {
76572       {
76573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76574       };
76575     } catch (...) {
76576       {
76577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76578       };
76579     }
76580   }
76581
76582 }
76583
76584
76585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
76586   void * jresult ;
76587   float arg1 ;
76588   float arg2 ;
76589   bool arg3 ;
76590   Dali::Toolkit::RulerDomain *result = 0 ;
76591
76592   arg1 = (float)jarg1;
76593   arg2 = (float)jarg2;
76594   arg3 = jarg3 ? true : false;
76595   {
76596     try {
76597       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
76598     } catch (std::out_of_range& e) {
76599       {
76600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76601       };
76602     } catch (std::exception& e) {
76603       {
76604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76605       };
76606     } catch (Dali::DaliException e) {
76607       {
76608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76609       };
76610     } catch (...) {
76611       {
76612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76613       };
76614     }
76615   }
76616
76617   jresult = (void *)result;
76618   return jresult;
76619 }
76620
76621
76622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
76623   void * jresult ;
76624   float arg1 ;
76625   float arg2 ;
76626   Dali::Toolkit::RulerDomain *result = 0 ;
76627
76628   arg1 = (float)jarg1;
76629   arg2 = (float)jarg2;
76630   {
76631     try {
76632       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
76633     } catch (std::out_of_range& e) {
76634       {
76635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76636       };
76637     } catch (std::exception& e) {
76638       {
76639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76640       };
76641     } catch (Dali::DaliException e) {
76642       {
76643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76644       };
76645     } catch (...) {
76646       {
76647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76648       };
76649     }
76650   }
76651
76652   jresult = (void *)result;
76653   return jresult;
76654 }
76655
76656
76657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
76658   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76659   float arg2 ;
76660
76661   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76662   arg2 = (float)jarg2;
76663   if (arg1) (arg1)->min = arg2;
76664 }
76665
76666
76667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
76668   float jresult ;
76669   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76670   float result;
76671
76672   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76673   result = (float) ((arg1)->min);
76674   jresult = result;
76675   return jresult;
76676 }
76677
76678
76679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
76680   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76681   float arg2 ;
76682
76683   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76684   arg2 = (float)jarg2;
76685   if (arg1) (arg1)->max = arg2;
76686 }
76687
76688
76689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
76690   float jresult ;
76691   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76692   float result;
76693
76694   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76695   result = (float) ((arg1)->max);
76696   jresult = result;
76697   return jresult;
76698 }
76699
76700
76701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
76702   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76703   bool arg2 ;
76704
76705   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76706   arg2 = jarg2 ? true : false;
76707   if (arg1) (arg1)->enabled = arg2;
76708 }
76709
76710
76711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
76712   unsigned int jresult ;
76713   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76714   bool result;
76715
76716   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76717   result = (bool) ((arg1)->enabled);
76718   jresult = result;
76719   return jresult;
76720 }
76721
76722
76723 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
76724   float jresult ;
76725   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76726   float arg2 ;
76727   float arg3 ;
76728   float arg4 ;
76729   float result;
76730
76731   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76732   arg2 = (float)jarg2;
76733   arg3 = (float)jarg3;
76734   arg4 = (float)jarg4;
76735   {
76736     try {
76737       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
76738     } catch (std::out_of_range& e) {
76739       {
76740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76741       };
76742     } catch (std::exception& e) {
76743       {
76744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76745       };
76746     } catch (Dali::DaliException e) {
76747       {
76748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76749       };
76750     } catch (...) {
76751       {
76752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76753       };
76754     }
76755   }
76756
76757   jresult = result;
76758   return jresult;
76759 }
76760
76761
76762 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
76763   float jresult ;
76764   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76765   float arg2 ;
76766   float arg3 ;
76767   float result;
76768
76769   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76770   arg2 = (float)jarg2;
76771   arg3 = (float)jarg3;
76772   {
76773     try {
76774       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
76775     } catch (std::out_of_range& e) {
76776       {
76777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76778       };
76779     } catch (std::exception& e) {
76780       {
76781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76782       };
76783     } catch (Dali::DaliException e) {
76784       {
76785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76786       };
76787     } catch (...) {
76788       {
76789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76790       };
76791     }
76792   }
76793
76794   jresult = result;
76795   return jresult;
76796 }
76797
76798
76799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
76800   float jresult ;
76801   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76802   float arg2 ;
76803   float result;
76804
76805   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76806   arg2 = (float)jarg2;
76807   {
76808     try {
76809       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
76810     } catch (std::out_of_range& e) {
76811       {
76812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76813       };
76814     } catch (std::exception& e) {
76815       {
76816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76817       };
76818     } catch (Dali::DaliException e) {
76819       {
76820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76821       };
76822     } catch (...) {
76823       {
76824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76825       };
76826     }
76827   }
76828
76829   jresult = result;
76830   return jresult;
76831 }
76832
76833
76834 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
76835   float jresult ;
76836   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76837   float arg2 ;
76838   float arg3 ;
76839   float arg4 ;
76840   Dali::Toolkit::ClampState *arg5 = 0 ;
76841   float result;
76842
76843   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76844   arg2 = (float)jarg2;
76845   arg3 = (float)jarg3;
76846   arg4 = (float)jarg4;
76847   arg5 = (Dali::Toolkit::ClampState *)jarg5;
76848   if (!arg5) {
76849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
76850     return 0;
76851   }
76852   {
76853     try {
76854       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
76855     } catch (std::out_of_range& e) {
76856       {
76857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76858       };
76859     } catch (std::exception& e) {
76860       {
76861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76862       };
76863     } catch (Dali::DaliException e) {
76864       {
76865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76866       };
76867     } catch (...) {
76868       {
76869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76870       };
76871     }
76872   }
76873
76874   jresult = result;
76875   return jresult;
76876 }
76877
76878
76879 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
76880   float jresult ;
76881   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76882   float result;
76883
76884   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76885   {
76886     try {
76887       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
76888     } catch (std::out_of_range& e) {
76889       {
76890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76891       };
76892     } catch (std::exception& e) {
76893       {
76894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76895       };
76896     } catch (Dali::DaliException e) {
76897       {
76898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76899       };
76900     } catch (...) {
76901       {
76902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76903       };
76904     }
76905   }
76906
76907   jresult = result;
76908   return jresult;
76909 }
76910
76911
76912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
76913   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76914
76915   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76916   {
76917     try {
76918       delete arg1;
76919     } catch (std::out_of_range& e) {
76920       {
76921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76922       };
76923     } catch (std::exception& e) {
76924       {
76925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76926       };
76927     } catch (Dali::DaliException e) {
76928       {
76929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76930       };
76931     } catch (...) {
76932       {
76933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76934       };
76935     }
76936   }
76937
76938 }
76939
76940
76941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
76942   float jresult ;
76943   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76944   float arg2 ;
76945   float arg3 ;
76946   float result;
76947
76948   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76949   arg2 = (float)jarg2;
76950   arg3 = (float)jarg3;
76951   {
76952     try {
76953       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
76954     } catch (std::out_of_range& e) {
76955       {
76956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76957       };
76958     } catch (std::exception& e) {
76959       {
76960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76961       };
76962     } catch (Dali::DaliException e) {
76963       {
76964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76965       };
76966     } catch (...) {
76967       {
76968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76969       };
76970     }
76971   }
76972
76973   jresult = result;
76974   return jresult;
76975 }
76976
76977
76978 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
76979   float jresult ;
76980   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76981   float arg2 ;
76982   float result;
76983
76984   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76985   arg2 = (float)jarg2;
76986   {
76987     try {
76988       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
76989     } catch (std::out_of_range& e) {
76990       {
76991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76992       };
76993     } catch (std::exception& e) {
76994       {
76995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76996       };
76997     } catch (Dali::DaliException e) {
76998       {
76999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77000       };
77001     } catch (...) {
77002       {
77003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77004       };
77005     }
77006   }
77007
77008   jresult = result;
77009   return jresult;
77010 }
77011
77012
77013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77014   float jresult ;
77015   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77016   unsigned int arg2 ;
77017   unsigned int *arg3 = 0 ;
77018   bool arg4 ;
77019   float result;
77020
77021   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77022   arg2 = (unsigned int)jarg2;
77023   arg3 = (unsigned int *)jarg3;
77024   arg4 = jarg4 ? true : false;
77025   {
77026     try {
77027       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77028     } catch (std::out_of_range& e) {
77029       {
77030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77031       };
77032     } catch (std::exception& e) {
77033       {
77034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77035       };
77036     } catch (Dali::DaliException e) {
77037       {
77038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77039       };
77040     } catch (...) {
77041       {
77042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77043       };
77044     }
77045   }
77046
77047   jresult = result;
77048   return jresult;
77049 }
77050
77051
77052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77053   unsigned int jresult ;
77054   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77055   float arg2 ;
77056   bool arg3 ;
77057   unsigned int result;
77058
77059   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77060   arg2 = (float)jarg2;
77061   arg3 = jarg3 ? true : false;
77062   {
77063     try {
77064       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
77065     } catch (std::out_of_range& e) {
77066       {
77067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77068       };
77069     } catch (std::exception& e) {
77070       {
77071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77072       };
77073     } catch (Dali::DaliException e) {
77074       {
77075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77076       };
77077     } catch (...) {
77078       {
77079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77080       };
77081     }
77082   }
77083
77084   jresult = result;
77085   return jresult;
77086 }
77087
77088
77089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
77090   unsigned int jresult ;
77091   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77092   unsigned int result;
77093
77094   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77095   {
77096     try {
77097       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
77098     } catch (std::out_of_range& e) {
77099       {
77100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77101       };
77102     } catch (std::exception& e) {
77103       {
77104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77105       };
77106     } catch (Dali::DaliException e) {
77107       {
77108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77109       };
77110     } catch (...) {
77111       {
77112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77113       };
77114     }
77115   }
77116
77117   jresult = result;
77118   return jresult;
77119 }
77120
77121
77122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
77123   int jresult ;
77124   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77125   Dali::Toolkit::Ruler::RulerType result;
77126
77127   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77128   {
77129     try {
77130       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
77131     } catch (std::out_of_range& e) {
77132       {
77133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77134       };
77135     } catch (std::exception& e) {
77136       {
77137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77138       };
77139     } catch (Dali::DaliException e) {
77140       {
77141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77142       };
77143     } catch (...) {
77144       {
77145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77146       };
77147     }
77148   }
77149
77150   jresult = (int)result;
77151   return jresult;
77152 }
77153
77154
77155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
77156   unsigned int jresult ;
77157   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77158   bool result;
77159
77160   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77161   {
77162     try {
77163       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
77164     } catch (std::out_of_range& e) {
77165       {
77166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77167       };
77168     } catch (std::exception& e) {
77169       {
77170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77171       };
77172     } catch (Dali::DaliException e) {
77173       {
77174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77175       };
77176     } catch (...) {
77177       {
77178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77179       };
77180     }
77181   }
77182
77183   jresult = result;
77184   return jresult;
77185 }
77186
77187
77188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
77189   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77190
77191   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77192   {
77193     try {
77194       (arg1)->Enable();
77195     } catch (std::out_of_range& e) {
77196       {
77197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77198       };
77199     } catch (std::exception& e) {
77200       {
77201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77202       };
77203     } catch (Dali::DaliException e) {
77204       {
77205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77206       };
77207     } catch (...) {
77208       {
77209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77210       };
77211     }
77212   }
77213
77214 }
77215
77216
77217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
77218   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77219
77220   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77221   {
77222     try {
77223       (arg1)->Disable();
77224     } catch (std::out_of_range& e) {
77225       {
77226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77227       };
77228     } catch (std::exception& e) {
77229       {
77230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77231       };
77232     } catch (Dali::DaliException e) {
77233       {
77234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77235       };
77236     } catch (...) {
77237       {
77238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77239       };
77240     }
77241   }
77242
77243 }
77244
77245
77246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
77247   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77248   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
77249   Dali::Toolkit::RulerDomain *argp2 ;
77250
77251   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77252   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
77253   if (!argp2) {
77254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
77255     return ;
77256   }
77257   arg2 = *argp2;
77258   {
77259     try {
77260       (arg1)->SetDomain(arg2);
77261     } catch (std::out_of_range& e) {
77262       {
77263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77264       };
77265     } catch (std::exception& e) {
77266       {
77267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77268       };
77269     } catch (Dali::DaliException e) {
77270       {
77271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77272       };
77273     } catch (...) {
77274       {
77275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77276       };
77277     }
77278   }
77279
77280 }
77281
77282
77283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
77284   void * jresult ;
77285   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77286   Dali::Toolkit::RulerDomain *result = 0 ;
77287
77288   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77289   {
77290     try {
77291       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
77292     } catch (std::out_of_range& e) {
77293       {
77294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77295       };
77296     } catch (std::exception& e) {
77297       {
77298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77299       };
77300     } catch (Dali::DaliException e) {
77301       {
77302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77303       };
77304     } catch (...) {
77305       {
77306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77307       };
77308     }
77309   }
77310
77311   jresult = (void *)result;
77312   return jresult;
77313 }
77314
77315
77316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
77317   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77318
77319   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77320   {
77321     try {
77322       (arg1)->DisableDomain();
77323     } catch (std::out_of_range& e) {
77324       {
77325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77326       };
77327     } catch (std::exception& e) {
77328       {
77329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77330       };
77331     } catch (Dali::DaliException e) {
77332       {
77333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77334       };
77335     } catch (...) {
77336       {
77337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77338       };
77339     }
77340   }
77341
77342 }
77343
77344
77345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77346   float jresult ;
77347   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77348   float arg2 ;
77349   float arg3 ;
77350   float arg4 ;
77351   float result;
77352
77353   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77354   arg2 = (float)jarg2;
77355   arg3 = (float)jarg3;
77356   arg4 = (float)jarg4;
77357   {
77358     try {
77359       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
77360     } catch (std::out_of_range& e) {
77361       {
77362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77363       };
77364     } catch (std::exception& e) {
77365       {
77366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77367       };
77368     } catch (Dali::DaliException e) {
77369       {
77370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77371       };
77372     } catch (...) {
77373       {
77374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77375       };
77376     }
77377   }
77378
77379   jresult = result;
77380   return jresult;
77381 }
77382
77383
77384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77385   float jresult ;
77386   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77387   float arg2 ;
77388   float arg3 ;
77389   float result;
77390
77391   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77392   arg2 = (float)jarg2;
77393   arg3 = (float)jarg3;
77394   {
77395     try {
77396       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
77397     } catch (std::out_of_range& e) {
77398       {
77399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77400       };
77401     } catch (std::exception& e) {
77402       {
77403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77404       };
77405     } catch (Dali::DaliException e) {
77406       {
77407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77408       };
77409     } catch (...) {
77410       {
77411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77412       };
77413     }
77414   }
77415
77416   jresult = result;
77417   return jresult;
77418 }
77419
77420
77421 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
77422   float jresult ;
77423   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77424   float arg2 ;
77425   float result;
77426
77427   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77428   arg2 = (float)jarg2;
77429   {
77430     try {
77431       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
77432     } catch (std::out_of_range& e) {
77433       {
77434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77435       };
77436     } catch (std::exception& e) {
77437       {
77438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77439       };
77440     } catch (Dali::DaliException e) {
77441       {
77442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77443       };
77444     } catch (...) {
77445       {
77446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77447       };
77448     }
77449   }
77450
77451   jresult = result;
77452   return jresult;
77453 }
77454
77455
77456 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77457   float jresult ;
77458   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77459   float arg2 ;
77460   float arg3 ;
77461   float arg4 ;
77462   Dali::Toolkit::ClampState *arg5 = 0 ;
77463   float result;
77464
77465   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77466   arg2 = (float)jarg2;
77467   arg3 = (float)jarg3;
77468   arg4 = (float)jarg4;
77469   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77470   if (!arg5) {
77471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77472     return 0;
77473   }
77474   {
77475     try {
77476       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
77477     } catch (std::out_of_range& e) {
77478       {
77479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77480       };
77481     } catch (std::exception& e) {
77482       {
77483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77484       };
77485     } catch (Dali::DaliException e) {
77486       {
77487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77488       };
77489     } catch (...) {
77490       {
77491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77492       };
77493     }
77494   }
77495
77496   jresult = result;
77497   return jresult;
77498 }
77499
77500
77501 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
77502   float jresult ;
77503   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77504   float arg2 ;
77505   float arg3 ;
77506   float arg4 ;
77507   float arg5 ;
77508   float result;
77509
77510   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77511   arg2 = (float)jarg2;
77512   arg3 = (float)jarg3;
77513   arg4 = (float)jarg4;
77514   arg5 = (float)jarg5;
77515   {
77516     try {
77517       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
77518     } catch (std::out_of_range& e) {
77519       {
77520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77521       };
77522     } catch (std::exception& e) {
77523       {
77524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77525       };
77526     } catch (Dali::DaliException e) {
77527       {
77528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77529       };
77530     } catch (...) {
77531       {
77532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77533       };
77534     }
77535   }
77536
77537   jresult = result;
77538   return jresult;
77539 }
77540
77541
77542 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
77543   float jresult ;
77544   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77545   float arg2 ;
77546   float arg3 ;
77547   float arg4 ;
77548   float result;
77549
77550   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77551   arg2 = (float)jarg2;
77552   arg3 = (float)jarg3;
77553   arg4 = (float)jarg4;
77554   {
77555     try {
77556       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
77557     } catch (std::out_of_range& e) {
77558       {
77559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77560       };
77561     } catch (std::exception& e) {
77562       {
77563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77564       };
77565     } catch (Dali::DaliException e) {
77566       {
77567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77568       };
77569     } catch (...) {
77570       {
77571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77572       };
77573     }
77574   }
77575
77576   jresult = result;
77577   return jresult;
77578 }
77579
77580
77581 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
77582   float jresult ;
77583   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77584   float arg2 ;
77585   float arg3 ;
77586   float result;
77587
77588   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77589   arg2 = (float)jarg2;
77590   arg3 = (float)jarg3;
77591   {
77592     try {
77593       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
77594     } catch (std::out_of_range& e) {
77595       {
77596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77597       };
77598     } catch (std::exception& e) {
77599       {
77600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77601       };
77602     } catch (Dali::DaliException e) {
77603       {
77604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77605       };
77606     } catch (...) {
77607       {
77608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77609       };
77610     }
77611   }
77612
77613   jresult = result;
77614   return jresult;
77615 }
77616
77617
77618 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
77619   float jresult ;
77620   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77621   float arg2 ;
77622   float result;
77623
77624   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77625   arg2 = (float)jarg2;
77626   {
77627     try {
77628       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
77629     } catch (std::out_of_range& e) {
77630       {
77631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77632       };
77633     } catch (std::exception& e) {
77634       {
77635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77636       };
77637     } catch (Dali::DaliException e) {
77638       {
77639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77640       };
77641     } catch (...) {
77642       {
77643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77644       };
77645     }
77646   }
77647
77648   jresult = result;
77649   return jresult;
77650 }
77651
77652
77653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
77654   float jresult ;
77655   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77656   float arg2 ;
77657   float arg3 ;
77658   float arg4 ;
77659   float arg5 ;
77660   Dali::Toolkit::ClampState *arg6 = 0 ;
77661   float result;
77662
77663   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77664   arg2 = (float)jarg2;
77665   arg3 = (float)jarg3;
77666   arg4 = (float)jarg4;
77667   arg5 = (float)jarg5;
77668   arg6 = (Dali::Toolkit::ClampState *)jarg6;
77669   if (!arg6) {
77670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77671     return 0;
77672   }
77673   {
77674     try {
77675       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
77676     } catch (std::out_of_range& e) {
77677       {
77678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77679       };
77680     } catch (std::exception& e) {
77681       {
77682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77683       };
77684     } catch (Dali::DaliException e) {
77685       {
77686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77687       };
77688     } catch (...) {
77689       {
77690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77691       };
77692     }
77693   }
77694
77695   jresult = result;
77696   return jresult;
77697 }
77698
77699
77700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
77701   void * jresult ;
77702   Dali::Toolkit::DefaultRuler *result = 0 ;
77703
77704   {
77705     try {
77706       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
77707     } catch (std::out_of_range& e) {
77708       {
77709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77710       };
77711     } catch (std::exception& e) {
77712       {
77713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77714       };
77715     } catch (Dali::DaliException e) {
77716       {
77717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77718       };
77719     } catch (...) {
77720       {
77721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77722       };
77723     }
77724   }
77725
77726   jresult = (void *)result;
77727   return jresult;
77728 }
77729
77730
77731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
77732   float jresult ;
77733   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77734   float arg2 ;
77735   float arg3 ;
77736   float result;
77737
77738   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77739   arg2 = (float)jarg2;
77740   arg3 = (float)jarg3;
77741   {
77742     try {
77743       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
77744     } catch (std::out_of_range& e) {
77745       {
77746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77747       };
77748     } catch (std::exception& e) {
77749       {
77750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77751       };
77752     } catch (Dali::DaliException e) {
77753       {
77754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77755       };
77756     } catch (...) {
77757       {
77758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77759       };
77760     }
77761   }
77762
77763   jresult = result;
77764   return jresult;
77765 }
77766
77767
77768 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77769   float jresult ;
77770   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77771   unsigned int arg2 ;
77772   unsigned int *arg3 = 0 ;
77773   bool arg4 ;
77774   float result;
77775
77776   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77777   arg2 = (unsigned int)jarg2;
77778   arg3 = (unsigned int *)jarg3;
77779   arg4 = jarg4 ? true : false;
77780   {
77781     try {
77782       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77783     } catch (std::out_of_range& e) {
77784       {
77785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77786       };
77787     } catch (std::exception& e) {
77788       {
77789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77790       };
77791     } catch (Dali::DaliException e) {
77792       {
77793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77794       };
77795     } catch (...) {
77796       {
77797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77798       };
77799     }
77800   }
77801
77802   jresult = result;
77803   return jresult;
77804 }
77805
77806
77807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77808   unsigned int jresult ;
77809   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77810   float arg2 ;
77811   bool arg3 ;
77812   unsigned int result;
77813
77814   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77815   arg2 = (float)jarg2;
77816   arg3 = jarg3 ? true : false;
77817   {
77818     try {
77819       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
77820     } catch (std::out_of_range& e) {
77821       {
77822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77823       };
77824     } catch (std::exception& e) {
77825       {
77826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77827       };
77828     } catch (Dali::DaliException e) {
77829       {
77830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77831       };
77832     } catch (...) {
77833       {
77834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77835       };
77836     }
77837   }
77838
77839   jresult = result;
77840   return jresult;
77841 }
77842
77843
77844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
77845   unsigned int jresult ;
77846   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77847   unsigned int result;
77848
77849   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77850   {
77851     try {
77852       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
77853     } catch (std::out_of_range& e) {
77854       {
77855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77856       };
77857     } catch (std::exception& e) {
77858       {
77859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77860       };
77861     } catch (Dali::DaliException e) {
77862       {
77863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77864       };
77865     } catch (...) {
77866       {
77867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77868       };
77869     }
77870   }
77871
77872   jresult = result;
77873   return jresult;
77874 }
77875
77876
77877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
77878   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77879
77880   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77881   {
77882     try {
77883       delete arg1;
77884     } catch (std::out_of_range& e) {
77885       {
77886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77887       };
77888     } catch (std::exception& e) {
77889       {
77890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77891       };
77892     } catch (Dali::DaliException e) {
77893       {
77894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77895       };
77896     } catch (...) {
77897       {
77898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77899       };
77900     }
77901   }
77902
77903 }
77904
77905
77906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
77907   void * jresult ;
77908   float arg1 ;
77909   Dali::Toolkit::FixedRuler *result = 0 ;
77910
77911   arg1 = (float)jarg1;
77912   {
77913     try {
77914       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
77915     } catch (std::out_of_range& e) {
77916       {
77917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77918       };
77919     } catch (std::exception& e) {
77920       {
77921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77922       };
77923     } catch (Dali::DaliException e) {
77924       {
77925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77926       };
77927     } catch (...) {
77928       {
77929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77930       };
77931     }
77932   }
77933
77934   jresult = (void *)result;
77935   return jresult;
77936 }
77937
77938
77939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
77940   void * jresult ;
77941   Dali::Toolkit::FixedRuler *result = 0 ;
77942
77943   {
77944     try {
77945       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
77946     } catch (std::out_of_range& e) {
77947       {
77948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77949       };
77950     } catch (std::exception& e) {
77951       {
77952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77953       };
77954     } catch (Dali::DaliException e) {
77955       {
77956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77957       };
77958     } catch (...) {
77959       {
77960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77961       };
77962     }
77963   }
77964
77965   jresult = (void *)result;
77966   return jresult;
77967 }
77968
77969
77970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
77971   float jresult ;
77972   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
77973   float arg2 ;
77974   float arg3 ;
77975   float result;
77976
77977   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
77978   arg2 = (float)jarg2;
77979   arg3 = (float)jarg3;
77980   {
77981     try {
77982       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
77983     } catch (std::out_of_range& e) {
77984       {
77985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77986       };
77987     } catch (std::exception& e) {
77988       {
77989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77990       };
77991     } catch (Dali::DaliException e) {
77992       {
77993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77994       };
77995     } catch (...) {
77996       {
77997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77998       };
77999     }
78000   }
78001
78002   jresult = result;
78003   return jresult;
78004 }
78005
78006
78007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78008   float jresult ;
78009   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78010   unsigned int arg2 ;
78011   unsigned int *arg3 = 0 ;
78012   bool arg4 ;
78013   float result;
78014
78015   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78016   arg2 = (unsigned int)jarg2;
78017   arg3 = (unsigned int *)jarg3;
78018   arg4 = jarg4 ? true : false;
78019   {
78020     try {
78021       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78022     } catch (std::out_of_range& e) {
78023       {
78024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78025       };
78026     } catch (std::exception& e) {
78027       {
78028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78029       };
78030     } catch (Dali::DaliException e) {
78031       {
78032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78033       };
78034     } catch (...) {
78035       {
78036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78037       };
78038     }
78039   }
78040
78041   jresult = result;
78042   return jresult;
78043 }
78044
78045
78046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78047   unsigned int jresult ;
78048   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78049   float arg2 ;
78050   bool arg3 ;
78051   unsigned int result;
78052
78053   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78054   arg2 = (float)jarg2;
78055   arg3 = jarg3 ? true : false;
78056   {
78057     try {
78058       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78059     } catch (std::out_of_range& e) {
78060       {
78061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78062       };
78063     } catch (std::exception& e) {
78064       {
78065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78066       };
78067     } catch (Dali::DaliException e) {
78068       {
78069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78070       };
78071     } catch (...) {
78072       {
78073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78074       };
78075     }
78076   }
78077
78078   jresult = result;
78079   return jresult;
78080 }
78081
78082
78083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
78084   unsigned int jresult ;
78085   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78086   unsigned int result;
78087
78088   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78089   {
78090     try {
78091       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
78092     } catch (std::out_of_range& e) {
78093       {
78094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78095       };
78096     } catch (std::exception& e) {
78097       {
78098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78099       };
78100     } catch (Dali::DaliException e) {
78101       {
78102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78103       };
78104     } catch (...) {
78105       {
78106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78107       };
78108     }
78109   }
78110
78111   jresult = result;
78112   return jresult;
78113 }
78114
78115
78116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
78117   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78118
78119   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78120   {
78121     try {
78122       delete arg1;
78123     } catch (std::out_of_range& e) {
78124       {
78125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78126       };
78127     } catch (std::exception& e) {
78128       {
78129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78130       };
78131     } catch (Dali::DaliException e) {
78132       {
78133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78134       };
78135     } catch (...) {
78136       {
78137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78138       };
78139     }
78140   }
78141
78142 }
78143
78144
78145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
78146   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78147   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
78148
78149   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78150   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
78151   if (arg1) (arg1)->scale = *arg2;
78152 }
78153
78154
78155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
78156   void * jresult ;
78157   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78158   Dali::Toolkit::ClampState2D *result = 0 ;
78159
78160   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78161   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
78162   jresult = (void *)result;
78163   return jresult;
78164 }
78165
78166
78167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
78168   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78169   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
78170
78171   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78172   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
78173   if (arg1) (arg1)->position = *arg2;
78174 }
78175
78176
78177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
78178   void * jresult ;
78179   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78180   Dali::Toolkit::ClampState2D *result = 0 ;
78181
78182   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78183   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
78184   jresult = (void *)result;
78185   return jresult;
78186 }
78187
78188
78189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
78190   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78191   Dali::Toolkit::ClampState arg2 ;
78192
78193   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78194   arg2 = (Dali::Toolkit::ClampState)jarg2;
78195   if (arg1) (arg1)->rotation = arg2;
78196 }
78197
78198
78199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
78200   int jresult ;
78201   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78202   Dali::Toolkit::ClampState result;
78203
78204   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78205   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
78206   jresult = (int)result;
78207   return jresult;
78208 }
78209
78210
78211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
78212   void * jresult ;
78213   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
78214
78215   {
78216     try {
78217       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
78218     } catch (std::out_of_range& e) {
78219       {
78220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78221       };
78222     } catch (std::exception& e) {
78223       {
78224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78225       };
78226     } catch (Dali::DaliException e) {
78227       {
78228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78229       };
78230     } catch (...) {
78231       {
78232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78233       };
78234     }
78235   }
78236
78237   jresult = (void *)result;
78238   return jresult;
78239 }
78240
78241
78242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
78243   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78244
78245   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78246   {
78247     try {
78248       delete arg1;
78249     } catch (std::out_of_range& e) {
78250       {
78251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78252       };
78253     } catch (std::exception& e) {
78254       {
78255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78256       };
78257     } catch (Dali::DaliException e) {
78258       {
78259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78260       };
78261     } catch (...) {
78262       {
78263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78264       };
78265     }
78266   }
78267
78268 }
78269
78270
78271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
78272   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78273   Dali::Toolkit::SnapType arg2 ;
78274
78275   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78276   arg2 = (Dali::Toolkit::SnapType)jarg2;
78277   if (arg1) (arg1)->type = arg2;
78278 }
78279
78280
78281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
78282   int jresult ;
78283   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78284   Dali::Toolkit::SnapType result;
78285
78286   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78287   result = (Dali::Toolkit::SnapType) ((arg1)->type);
78288   jresult = (int)result;
78289   return jresult;
78290 }
78291
78292
78293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
78294   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78295   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
78296
78297   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78298   arg2 = (Dali::Vector2 *)jarg2;
78299   if (arg1) (arg1)->position = *arg2;
78300 }
78301
78302
78303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
78304   void * jresult ;
78305   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78306   Dali::Vector2 *result = 0 ;
78307
78308   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78309   result = (Dali::Vector2 *)& ((arg1)->position);
78310   jresult = (void *)result;
78311   return jresult;
78312 }
78313
78314
78315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
78316   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78317   float arg2 ;
78318
78319   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78320   arg2 = (float)jarg2;
78321   if (arg1) (arg1)->duration = arg2;
78322 }
78323
78324
78325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
78326   float jresult ;
78327   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78328   float result;
78329
78330   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78331   result = (float) ((arg1)->duration);
78332   jresult = result;
78333   return jresult;
78334 }
78335
78336
78337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
78338   void * jresult ;
78339   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
78340
78341   {
78342     try {
78343       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
78344     } catch (std::out_of_range& e) {
78345       {
78346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78347       };
78348     } catch (std::exception& e) {
78349       {
78350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78351       };
78352     } catch (Dali::DaliException e) {
78353       {
78354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78355       };
78356     } catch (...) {
78357       {
78358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78359       };
78360     }
78361   }
78362
78363   jresult = (void *)result;
78364   return jresult;
78365 }
78366
78367
78368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
78369   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78370
78371   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78372   {
78373     try {
78374       delete arg1;
78375     } catch (std::out_of_range& e) {
78376       {
78377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78378       };
78379     } catch (std::exception& e) {
78380       {
78381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78382       };
78383     } catch (Dali::DaliException e) {
78384       {
78385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78386       };
78387     } catch (...) {
78388       {
78389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78390       };
78391     }
78392   }
78393
78394 }
78395
78396
78397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
78398   int jresult ;
78399   int result;
78400
78401   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
78402   jresult = (int)result;
78403   return jresult;
78404 }
78405
78406
78407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
78408   int jresult ;
78409   int result;
78410
78411   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
78412   jresult = (int)result;
78413   return jresult;
78414 }
78415
78416
78417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
78418   int jresult ;
78419   int result;
78420
78421   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
78422   jresult = (int)result;
78423   return jresult;
78424 }
78425
78426
78427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
78428   int jresult ;
78429   int result;
78430
78431   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
78432   jresult = (int)result;
78433   return jresult;
78434 }
78435
78436
78437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
78438   int jresult ;
78439   int result;
78440
78441   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
78442   jresult = (int)result;
78443   return jresult;
78444 }
78445
78446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
78447   int jresult ;
78448   int result;
78449
78450   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
78451   jresult = (int)result;
78452   return jresult;
78453 }
78454
78455
78456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
78457   int jresult ;
78458   int result;
78459
78460   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
78461   jresult = (int)result;
78462   return jresult;
78463 }
78464
78465
78466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
78467   int jresult ;
78468   int result;
78469
78470   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
78471   jresult = (int)result;
78472   return jresult;
78473 }
78474
78475
78476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
78477   int jresult ;
78478   int result;
78479
78480   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
78481   jresult = (int)result;
78482   return jresult;
78483 }
78484
78485
78486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
78487   int jresult ;
78488   int result;
78489
78490   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
78491   jresult = (int)result;
78492   return jresult;
78493 }
78494
78495
78496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
78497   int jresult ;
78498   int result;
78499
78500   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
78501   jresult = (int)result;
78502   return jresult;
78503 }
78504
78505
78506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
78507   int jresult ;
78508   int result;
78509
78510   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
78511   jresult = (int)result;
78512   return jresult;
78513 }
78514
78515
78516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
78517   int jresult ;
78518   int result;
78519
78520   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
78521   jresult = (int)result;
78522   return jresult;
78523 }
78524
78525
78526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
78527   int jresult ;
78528   int result;
78529
78530   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
78531   jresult = (int)result;
78532   return jresult;
78533 }
78534
78535
78536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
78537   int jresult ;
78538   int result;
78539
78540   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
78541   jresult = (int)result;
78542   return jresult;
78543 }
78544
78545
78546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
78547   int jresult ;
78548   int result;
78549
78550   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
78551   jresult = (int)result;
78552   return jresult;
78553 }
78554
78555
78556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
78557   int jresult ;
78558   int result;
78559
78560   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
78561   jresult = (int)result;
78562   return jresult;
78563 }
78564
78565
78566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
78567   int jresult ;
78568   int result;
78569
78570   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
78571   jresult = (int)result;
78572   return jresult;
78573 }
78574
78575
78576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
78577   int jresult ;
78578   int result;
78579
78580   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
78581   jresult = (int)result;
78582   return jresult;
78583 }
78584
78585
78586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
78587   int jresult ;
78588   int result;
78589
78590   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
78591   jresult = (int)result;
78592   return jresult;
78593 }
78594
78595
78596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
78597   int jresult ;
78598   int result;
78599
78600   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
78601   jresult = (int)result;
78602   return jresult;
78603 }
78604
78605
78606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
78607   int jresult ;
78608   int result;
78609
78610   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
78611   jresult = (int)result;
78612   return jresult;
78613 }
78614
78615
78616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
78617   int jresult ;
78618   int result;
78619
78620   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
78621   jresult = (int)result;
78622   return jresult;
78623 }
78624
78625
78626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
78627   int jresult ;
78628   int result;
78629
78630   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
78631   jresult = (int)result;
78632   return jresult;
78633 }
78634
78635
78636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
78637   int jresult ;
78638   int result;
78639
78640   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
78641   jresult = (int)result;
78642   return jresult;
78643 }
78644
78645
78646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
78647   int jresult ;
78648   int result;
78649
78650   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
78651   jresult = (int)result;
78652   return jresult;
78653 }
78654
78655
78656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
78657   void * jresult ;
78658   Dali::Toolkit::ScrollView::Property *result = 0 ;
78659
78660   {
78661     try {
78662       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
78663     } catch (std::out_of_range& e) {
78664       {
78665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78666       };
78667     } catch (std::exception& e) {
78668       {
78669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78670       };
78671     } catch (Dali::DaliException e) {
78672       {
78673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78674       };
78675     } catch (...) {
78676       {
78677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78678       };
78679     }
78680   }
78681
78682   jresult = (void *)result;
78683   return jresult;
78684 }
78685
78686
78687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
78688   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
78689
78690   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
78691   {
78692     try {
78693       delete arg1;
78694     } catch (std::out_of_range& e) {
78695       {
78696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78697       };
78698     } catch (std::exception& e) {
78699       {
78700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78701       };
78702     } catch (Dali::DaliException e) {
78703       {
78704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78705       };
78706     } catch (...) {
78707       {
78708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78709       };
78710     }
78711   }
78712
78713 }
78714
78715
78716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
78717   void * jresult ;
78718   Dali::Toolkit::ScrollView *result = 0 ;
78719
78720   {
78721     try {
78722       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
78723     } catch (std::out_of_range& e) {
78724       {
78725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78726       };
78727     } catch (std::exception& e) {
78728       {
78729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78730       };
78731     } catch (Dali::DaliException e) {
78732       {
78733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78734       };
78735     } catch (...) {
78736       {
78737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78738       };
78739     }
78740   }
78741
78742   jresult = (void *)result;
78743   return jresult;
78744 }
78745
78746
78747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
78748   void * jresult ;
78749   Dali::Toolkit::ScrollView *arg1 = 0 ;
78750   Dali::Toolkit::ScrollView *result = 0 ;
78751
78752   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78753   if (!arg1) {
78754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78755     return 0;
78756   }
78757   {
78758     try {
78759       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
78760     } catch (std::out_of_range& e) {
78761       {
78762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78763       };
78764     } catch (std::exception& e) {
78765       {
78766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78767       };
78768     } catch (Dali::DaliException e) {
78769       {
78770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78771       };
78772     } catch (...) {
78773       {
78774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78775       };
78776     }
78777   }
78778
78779   jresult = (void *)result;
78780   return jresult;
78781 }
78782
78783
78784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
78785   void * jresult ;
78786   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78787   Dali::Toolkit::ScrollView *arg2 = 0 ;
78788   Dali::Toolkit::ScrollView *result = 0 ;
78789
78790   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78791   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
78792   if (!arg2) {
78793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78794     return 0;
78795   }
78796   {
78797     try {
78798       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
78799     } catch (std::out_of_range& e) {
78800       {
78801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78802       };
78803     } catch (std::exception& e) {
78804       {
78805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78806       };
78807     } catch (Dali::DaliException e) {
78808       {
78809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78810       };
78811     } catch (...) {
78812       {
78813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78814       };
78815     }
78816   }
78817
78818   jresult = (void *)result;
78819   return jresult;
78820 }
78821
78822
78823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
78824   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78825
78826   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78827   {
78828     try {
78829       delete arg1;
78830     } catch (std::out_of_range& e) {
78831       {
78832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78833       };
78834     } catch (std::exception& e) {
78835       {
78836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78837       };
78838     } catch (Dali::DaliException e) {
78839       {
78840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78841       };
78842     } catch (...) {
78843       {
78844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78845       };
78846     }
78847   }
78848
78849 }
78850
78851
78852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
78853   void * jresult ;
78854   Dali::Toolkit::ScrollView result;
78855
78856   {
78857     try {
78858       result = Dali::Toolkit::ScrollView::New();
78859     } catch (std::out_of_range& e) {
78860       {
78861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78862       };
78863     } catch (std::exception& e) {
78864       {
78865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78866       };
78867     } catch (Dali::DaliException e) {
78868       {
78869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78870       };
78871     } catch (...) {
78872       {
78873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78874       };
78875     }
78876   }
78877
78878   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
78879   return jresult;
78880 }
78881
78882
78883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
78884   void * jresult ;
78885   Dali::BaseHandle arg1 ;
78886   Dali::BaseHandle *argp1 ;
78887   Dali::Toolkit::ScrollView result;
78888
78889   argp1 = (Dali::BaseHandle *)jarg1;
78890   if (!argp1) {
78891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78892     return 0;
78893   }
78894   arg1 = *argp1;
78895   {
78896     try {
78897       result = Dali::Toolkit::ScrollView::DownCast(arg1);
78898     } catch (std::out_of_range& e) {
78899       {
78900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78901       };
78902     } catch (std::exception& e) {
78903       {
78904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78905       };
78906     } catch (Dali::DaliException e) {
78907       {
78908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78909       };
78910     } catch (...) {
78911       {
78912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78913       };
78914     }
78915   }
78916
78917   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
78918   return jresult;
78919 }
78920
78921
78922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
78923   void * jresult ;
78924   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78925   Dali::AlphaFunction result;
78926
78927   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78928   {
78929     try {
78930       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
78931     } catch (std::out_of_range& e) {
78932       {
78933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78934       };
78935     } catch (std::exception& e) {
78936       {
78937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78938       };
78939     } catch (Dali::DaliException e) {
78940       {
78941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78942       };
78943     } catch (...) {
78944       {
78945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78946       };
78947     }
78948   }
78949
78950   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
78951   return jresult;
78952 }
78953
78954
78955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
78956   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78957   Dali::AlphaFunction arg2 ;
78958   Dali::AlphaFunction *argp2 ;
78959
78960   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78961   argp2 = (Dali::AlphaFunction *)jarg2;
78962   if (!argp2) {
78963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
78964     return ;
78965   }
78966   arg2 = *argp2;
78967   {
78968     try {
78969       (arg1)->SetScrollSnapAlphaFunction(arg2);
78970     } catch (std::out_of_range& e) {
78971       {
78972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78973       };
78974     } catch (std::exception& e) {
78975       {
78976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78977       };
78978     } catch (Dali::DaliException e) {
78979       {
78980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78981       };
78982     } catch (...) {
78983       {
78984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78985       };
78986     }
78987   }
78988
78989 }
78990
78991
78992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
78993   void * jresult ;
78994   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78995   Dali::AlphaFunction result;
78996
78997   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78998   {
78999     try {
79000       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
79001     } catch (std::out_of_range& e) {
79002       {
79003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79004       };
79005     } catch (std::exception& e) {
79006       {
79007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79008       };
79009     } catch (Dali::DaliException e) {
79010       {
79011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79012       };
79013     } catch (...) {
79014       {
79015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79016       };
79017     }
79018   }
79019
79020   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79021   return jresult;
79022 }
79023
79024
79025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
79026   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79027   Dali::AlphaFunction arg2 ;
79028   Dali::AlphaFunction *argp2 ;
79029
79030   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79031   argp2 = (Dali::AlphaFunction *)jarg2;
79032   if (!argp2) {
79033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79034     return ;
79035   }
79036   arg2 = *argp2;
79037   {
79038     try {
79039       (arg1)->SetScrollFlickAlphaFunction(arg2);
79040     } catch (std::out_of_range& e) {
79041       {
79042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79043       };
79044     } catch (std::exception& e) {
79045       {
79046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79047       };
79048     } catch (Dali::DaliException e) {
79049       {
79050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79051       };
79052     } catch (...) {
79053       {
79054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79055       };
79056     }
79057   }
79058
79059 }
79060
79061
79062 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
79063   float jresult ;
79064   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79065   float result;
79066
79067   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79068   {
79069     try {
79070       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
79071     } catch (std::out_of_range& e) {
79072       {
79073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79074       };
79075     } catch (std::exception& e) {
79076       {
79077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79078       };
79079     } catch (Dali::DaliException e) {
79080       {
79081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79082       };
79083     } catch (...) {
79084       {
79085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79086       };
79087     }
79088   }
79089
79090   jresult = result;
79091   return jresult;
79092 }
79093
79094
79095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
79096   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79097   float arg2 ;
79098
79099   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79100   arg2 = (float)jarg2;
79101   {
79102     try {
79103       (arg1)->SetScrollSnapDuration(arg2);
79104     } catch (std::out_of_range& e) {
79105       {
79106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79107       };
79108     } catch (std::exception& e) {
79109       {
79110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79111       };
79112     } catch (Dali::DaliException e) {
79113       {
79114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79115       };
79116     } catch (...) {
79117       {
79118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79119       };
79120     }
79121   }
79122
79123 }
79124
79125
79126 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
79127   float jresult ;
79128   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79129   float result;
79130
79131   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79132   {
79133     try {
79134       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
79135     } catch (std::out_of_range& e) {
79136       {
79137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79138       };
79139     } catch (std::exception& e) {
79140       {
79141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79142       };
79143     } catch (Dali::DaliException e) {
79144       {
79145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79146       };
79147     } catch (...) {
79148       {
79149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79150       };
79151     }
79152   }
79153
79154   jresult = result;
79155   return jresult;
79156 }
79157
79158
79159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
79160   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79161   float arg2 ;
79162
79163   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79164   arg2 = (float)jarg2;
79165   {
79166     try {
79167       (arg1)->SetScrollFlickDuration(arg2);
79168     } catch (std::out_of_range& e) {
79169       {
79170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79171       };
79172     } catch (std::exception& e) {
79173       {
79174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79175       };
79176     } catch (Dali::DaliException e) {
79177       {
79178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79179       };
79180     } catch (...) {
79181       {
79182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79183       };
79184     }
79185   }
79186
79187 }
79188
79189
79190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
79191   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79192   Dali::Toolkit::RulerPtr arg2 ;
79193   Dali::Toolkit::RulerPtr *argp2 ;
79194
79195   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79196   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
79197   if (!argp2) {
79198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
79199     return ;
79200   }
79201   arg2 = *argp2;
79202   {
79203     try {
79204       (arg1)->SetRulerX(arg2);
79205     } catch (std::out_of_range& e) {
79206       {
79207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79208       };
79209     } catch (std::exception& e) {
79210       {
79211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79212       };
79213     } catch (Dali::DaliException e) {
79214       {
79215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79216       };
79217     } catch (...) {
79218       {
79219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79220       };
79221     }
79222   }
79223
79224 }
79225
79226
79227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
79228   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79229   Dali::Toolkit::RulerPtr arg2 ;
79230   Dali::Toolkit::RulerPtr *argp2 ;
79231
79232   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79233   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
79234   if (!argp2) {
79235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
79236     return ;
79237   }
79238   arg2 = *argp2;
79239   {
79240     try {
79241       (arg1)->SetRulerY(arg2);
79242     } catch (std::out_of_range& e) {
79243       {
79244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79245       };
79246     } catch (std::exception& e) {
79247       {
79248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79249       };
79250     } catch (Dali::DaliException e) {
79251       {
79252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79253       };
79254     } catch (...) {
79255       {
79256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79257       };
79258     }
79259   }
79260
79261 }
79262
79263
79264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
79265   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79266   bool arg2 ;
79267
79268   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79269   arg2 = jarg2 ? true : false;
79270   {
79271     try {
79272       (arg1)->SetScrollSensitive(arg2);
79273     } catch (std::out_of_range& e) {
79274       {
79275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79276       };
79277     } catch (std::exception& e) {
79278       {
79279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79280       };
79281     } catch (Dali::DaliException e) {
79282       {
79283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79284       };
79285     } catch (...) {
79286       {
79287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79288       };
79289     }
79290   }
79291
79292 }
79293
79294
79295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
79296   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79297   float arg2 ;
79298   float arg3 ;
79299
79300   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79301   arg2 = (float)jarg2;
79302   arg3 = (float)jarg3;
79303   {
79304     try {
79305       (arg1)->SetMaxOvershoot(arg2,arg3);
79306     } catch (std::out_of_range& e) {
79307       {
79308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79309       };
79310     } catch (std::exception& e) {
79311       {
79312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79313       };
79314     } catch (Dali::DaliException e) {
79315       {
79316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79317       };
79318     } catch (...) {
79319       {
79320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79321       };
79322     }
79323   }
79324
79325 }
79326
79327
79328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
79329   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79330   Dali::AlphaFunction arg2 ;
79331   Dali::AlphaFunction *argp2 ;
79332
79333   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79334   argp2 = (Dali::AlphaFunction *)jarg2;
79335   if (!argp2) {
79336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79337     return ;
79338   }
79339   arg2 = *argp2;
79340   {
79341     try {
79342       (arg1)->SetSnapOvershootAlphaFunction(arg2);
79343     } catch (std::out_of_range& e) {
79344       {
79345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79346       };
79347     } catch (std::exception& e) {
79348       {
79349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79350       };
79351     } catch (Dali::DaliException e) {
79352       {
79353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79354       };
79355     } catch (...) {
79356       {
79357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79358       };
79359     }
79360   }
79361
79362 }
79363
79364
79365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
79366   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79367   float arg2 ;
79368
79369   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79370   arg2 = (float)jarg2;
79371   {
79372     try {
79373       (arg1)->SetSnapOvershootDuration(arg2);
79374     } catch (std::out_of_range& e) {
79375       {
79376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79377       };
79378     } catch (std::exception& e) {
79379       {
79380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79381       };
79382     } catch (Dali::DaliException e) {
79383       {
79384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79385       };
79386     } catch (...) {
79387       {
79388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79389       };
79390     }
79391   }
79392
79393 }
79394
79395
79396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
79397   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79398   bool arg2 ;
79399
79400   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79401   arg2 = jarg2 ? true : false;
79402   {
79403     try {
79404       (arg1)->SetActorAutoSnap(arg2);
79405     } catch (std::out_of_range& e) {
79406       {
79407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79408       };
79409     } catch (std::exception& e) {
79410       {
79411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79412       };
79413     } catch (Dali::DaliException e) {
79414       {
79415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79416       };
79417     } catch (...) {
79418       {
79419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79420       };
79421     }
79422   }
79423
79424 }
79425
79426
79427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
79428   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79429   bool arg2 ;
79430
79431   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79432   arg2 = jarg2 ? true : false;
79433   {
79434     try {
79435       (arg1)->SetWrapMode(arg2);
79436     } catch (std::out_of_range& e) {
79437       {
79438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79439       };
79440     } catch (std::exception& e) {
79441       {
79442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79443       };
79444     } catch (Dali::DaliException e) {
79445       {
79446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79447       };
79448     } catch (...) {
79449       {
79450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79451       };
79452     }
79453   }
79454
79455 }
79456
79457
79458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
79459   int jresult ;
79460   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79461   int result;
79462
79463   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79464   {
79465     try {
79466       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
79467     } catch (std::out_of_range& e) {
79468       {
79469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79470       };
79471     } catch (std::exception& e) {
79472       {
79473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79474       };
79475     } catch (Dali::DaliException e) {
79476       {
79477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79478       };
79479     } catch (...) {
79480       {
79481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79482       };
79483     }
79484   }
79485
79486   jresult = result;
79487   return jresult;
79488 }
79489
79490
79491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
79492   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79493   int arg2 ;
79494
79495   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79496   arg2 = (int)jarg2;
79497   {
79498     try {
79499       (arg1)->SetScrollUpdateDistance(arg2);
79500     } catch (std::out_of_range& e) {
79501       {
79502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79503       };
79504     } catch (std::exception& e) {
79505       {
79506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79507       };
79508     } catch (Dali::DaliException e) {
79509       {
79510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79511       };
79512     } catch (...) {
79513       {
79514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79515       };
79516     }
79517   }
79518
79519 }
79520
79521
79522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
79523   unsigned int jresult ;
79524   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79525   bool result;
79526
79527   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79528   {
79529     try {
79530       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
79531     } catch (std::out_of_range& e) {
79532       {
79533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79534       };
79535     } catch (std::exception& e) {
79536       {
79537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79538       };
79539     } catch (Dali::DaliException e) {
79540       {
79541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79542       };
79543     } catch (...) {
79544       {
79545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79546       };
79547     }
79548   }
79549
79550   jresult = result;
79551   return jresult;
79552 }
79553
79554
79555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
79556   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79557   bool arg2 ;
79558
79559   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79560   arg2 = jarg2 ? true : false;
79561   {
79562     try {
79563       (arg1)->SetAxisAutoLock(arg2);
79564     } catch (std::out_of_range& e) {
79565       {
79566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79567       };
79568     } catch (std::exception& e) {
79569       {
79570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79571       };
79572     } catch (Dali::DaliException e) {
79573       {
79574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79575       };
79576     } catch (...) {
79577       {
79578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79579       };
79580     }
79581   }
79582
79583 }
79584
79585
79586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
79587   float jresult ;
79588   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79589   float result;
79590
79591   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79592   {
79593     try {
79594       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
79595     } catch (std::out_of_range& e) {
79596       {
79597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79598       };
79599     } catch (std::exception& e) {
79600       {
79601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79602       };
79603     } catch (Dali::DaliException e) {
79604       {
79605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79606       };
79607     } catch (...) {
79608       {
79609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79610       };
79611     }
79612   }
79613
79614   jresult = result;
79615   return jresult;
79616 }
79617
79618
79619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
79620   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79621   float arg2 ;
79622
79623   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79624   arg2 = (float)jarg2;
79625   {
79626     try {
79627       (arg1)->SetAxisAutoLockGradient(arg2);
79628     } catch (std::out_of_range& e) {
79629       {
79630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79631       };
79632     } catch (std::exception& e) {
79633       {
79634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79635       };
79636     } catch (Dali::DaliException e) {
79637       {
79638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79639       };
79640     } catch (...) {
79641       {
79642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79643       };
79644     }
79645   }
79646
79647 }
79648
79649
79650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
79651   float jresult ;
79652   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79653   float result;
79654
79655   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79656   {
79657     try {
79658       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
79659     } catch (std::out_of_range& e) {
79660       {
79661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79662       };
79663     } catch (std::exception& e) {
79664       {
79665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79666       };
79667     } catch (Dali::DaliException e) {
79668       {
79669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79670       };
79671     } catch (...) {
79672       {
79673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79674       };
79675     }
79676   }
79677
79678   jresult = result;
79679   return jresult;
79680 }
79681
79682
79683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
79684   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79685   float arg2 ;
79686
79687   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79688   arg2 = (float)jarg2;
79689   {
79690     try {
79691       (arg1)->SetFrictionCoefficient(arg2);
79692     } catch (std::out_of_range& e) {
79693       {
79694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79695       };
79696     } catch (std::exception& e) {
79697       {
79698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79699       };
79700     } catch (Dali::DaliException e) {
79701       {
79702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79703       };
79704     } catch (...) {
79705       {
79706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79707       };
79708     }
79709   }
79710
79711 }
79712
79713
79714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
79715   float jresult ;
79716   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79717   float result;
79718
79719   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79720   {
79721     try {
79722       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
79723     } catch (std::out_of_range& e) {
79724       {
79725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79726       };
79727     } catch (std::exception& e) {
79728       {
79729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79730       };
79731     } catch (Dali::DaliException e) {
79732       {
79733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79734       };
79735     } catch (...) {
79736       {
79737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79738       };
79739     }
79740   }
79741
79742   jresult = result;
79743   return jresult;
79744 }
79745
79746
79747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
79748   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79749   float arg2 ;
79750
79751   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79752   arg2 = (float)jarg2;
79753   {
79754     try {
79755       (arg1)->SetFlickSpeedCoefficient(arg2);
79756     } catch (std::out_of_range& e) {
79757       {
79758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79759       };
79760     } catch (std::exception& e) {
79761       {
79762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79763       };
79764     } catch (Dali::DaliException e) {
79765       {
79766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79767       };
79768     } catch (...) {
79769       {
79770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79771       };
79772     }
79773   }
79774
79775 }
79776
79777
79778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
79779   void * jresult ;
79780   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79781   Dali::Vector2 result;
79782
79783   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79784   {
79785     try {
79786       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
79787     } catch (std::out_of_range& e) {
79788       {
79789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79790       };
79791     } catch (std::exception& e) {
79792       {
79793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79794       };
79795     } catch (Dali::DaliException e) {
79796       {
79797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79798       };
79799     } catch (...) {
79800       {
79801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79802       };
79803     }
79804   }
79805
79806   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79807   return jresult;
79808 }
79809
79810
79811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
79812   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79813   Dali::Vector2 *arg2 = 0 ;
79814
79815   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79816   arg2 = (Dali::Vector2 *)jarg2;
79817   if (!arg2) {
79818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
79819     return ;
79820   }
79821   {
79822     try {
79823       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
79824     } catch (std::out_of_range& e) {
79825       {
79826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79827       };
79828     } catch (std::exception& e) {
79829       {
79830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79831       };
79832     } catch (Dali::DaliException e) {
79833       {
79834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79835       };
79836     } catch (...) {
79837       {
79838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79839       };
79840     }
79841   }
79842
79843 }
79844
79845
79846 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
79847   float jresult ;
79848   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79849   float result;
79850
79851   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79852   {
79853     try {
79854       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
79855     } catch (std::out_of_range& e) {
79856       {
79857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79858       };
79859     } catch (std::exception& e) {
79860       {
79861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79862       };
79863     } catch (Dali::DaliException e) {
79864       {
79865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79866       };
79867     } catch (...) {
79868       {
79869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79870       };
79871     }
79872   }
79873
79874   jresult = result;
79875   return jresult;
79876 }
79877
79878
79879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
79880   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79881   float arg2 ;
79882
79883   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79884   arg2 = (float)jarg2;
79885   {
79886     try {
79887       (arg1)->SetMinimumSpeedForFlick(arg2);
79888     } catch (std::out_of_range& e) {
79889       {
79890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79891       };
79892     } catch (std::exception& e) {
79893       {
79894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79895       };
79896     } catch (Dali::DaliException e) {
79897       {
79898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79899       };
79900     } catch (...) {
79901       {
79902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79903       };
79904     }
79905   }
79906
79907 }
79908
79909
79910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
79911   float jresult ;
79912   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79913   float result;
79914
79915   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79916   {
79917     try {
79918       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
79919     } catch (std::out_of_range& e) {
79920       {
79921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79922       };
79923     } catch (std::exception& e) {
79924       {
79925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79926       };
79927     } catch (Dali::DaliException e) {
79928       {
79929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79930       };
79931     } catch (...) {
79932       {
79933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79934       };
79935     }
79936   }
79937
79938   jresult = result;
79939   return jresult;
79940 }
79941
79942
79943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
79944   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79945   float arg2 ;
79946
79947   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79948   arg2 = (float)jarg2;
79949   {
79950     try {
79951       (arg1)->SetMaxFlickSpeed(arg2);
79952     } catch (std::out_of_range& e) {
79953       {
79954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79955       };
79956     } catch (std::exception& e) {
79957       {
79958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79959       };
79960     } catch (Dali::DaliException e) {
79961       {
79962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79963       };
79964     } catch (...) {
79965       {
79966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79967       };
79968     }
79969   }
79970
79971 }
79972
79973
79974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
79975   void * jresult ;
79976   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79977   Dali::Vector2 result;
79978
79979   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79980   {
79981     try {
79982       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
79983     } catch (std::out_of_range& e) {
79984       {
79985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79986       };
79987     } catch (std::exception& e) {
79988       {
79989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79990       };
79991     } catch (Dali::DaliException e) {
79992       {
79993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79994       };
79995     } catch (...) {
79996       {
79997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79998       };
79999     }
80000   }
80001
80002   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80003   return jresult;
80004 }
80005
80006
80007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
80008   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80009   Dali::Vector2 arg2 ;
80010   Dali::Vector2 *argp2 ;
80011
80012   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80013   argp2 = (Dali::Vector2 *)jarg2;
80014   if (!argp2) {
80015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
80016     return ;
80017   }
80018   arg2 = *argp2;
80019   {
80020     try {
80021       (arg1)->SetWheelScrollDistanceStep(arg2);
80022     } catch (std::out_of_range& e) {
80023       {
80024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80025       };
80026     } catch (std::exception& e) {
80027       {
80028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80029       };
80030     } catch (Dali::DaliException e) {
80031       {
80032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80033       };
80034     } catch (...) {
80035       {
80036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80037       };
80038     }
80039   }
80040
80041 }
80042
80043
80044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
80045   void * jresult ;
80046   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80047   Dali::Vector2 result;
80048
80049   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80050   {
80051     try {
80052       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
80053     } catch (std::out_of_range& e) {
80054       {
80055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80056       };
80057     } catch (std::exception& e) {
80058       {
80059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80060       };
80061     } catch (Dali::DaliException e) {
80062       {
80063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80064       };
80065     } catch (...) {
80066       {
80067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80068       };
80069     }
80070   }
80071
80072   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80073   return jresult;
80074 }
80075
80076
80077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
80078   unsigned int jresult ;
80079   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80080   unsigned int result;
80081
80082   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80083   {
80084     try {
80085       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
80086     } catch (std::out_of_range& e) {
80087       {
80088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80089       };
80090     } catch (std::exception& e) {
80091       {
80092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80093       };
80094     } catch (Dali::DaliException e) {
80095       {
80096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80097       };
80098     } catch (...) {
80099       {
80100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80101       };
80102     }
80103   }
80104
80105   jresult = result;
80106   return jresult;
80107 }
80108
80109
80110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
80111   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80112   Dali::Vector2 *arg2 = 0 ;
80113
80114   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80115   arg2 = (Dali::Vector2 *)jarg2;
80116   if (!arg2) {
80117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80118     return ;
80119   }
80120   {
80121     try {
80122       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
80123     } catch (std::out_of_range& e) {
80124       {
80125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80126       };
80127     } catch (std::exception& e) {
80128       {
80129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80130       };
80131     } catch (Dali::DaliException e) {
80132       {
80133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80134       };
80135     } catch (...) {
80136       {
80137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80138       };
80139     }
80140   }
80141
80142 }
80143
80144
80145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
80146   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80147   Dali::Vector2 *arg2 = 0 ;
80148   float arg3 ;
80149
80150   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80151   arg2 = (Dali::Vector2 *)jarg2;
80152   if (!arg2) {
80153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80154     return ;
80155   }
80156   arg3 = (float)jarg3;
80157   {
80158     try {
80159       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
80160     } catch (std::out_of_range& e) {
80161       {
80162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80163       };
80164     } catch (std::exception& e) {
80165       {
80166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80167       };
80168     } catch (Dali::DaliException e) {
80169       {
80170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80171       };
80172     } catch (...) {
80173       {
80174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80175       };
80176     }
80177   }
80178
80179 }
80180
80181
80182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
80183   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80184   Dali::Vector2 *arg2 = 0 ;
80185   float arg3 ;
80186   Dali::AlphaFunction arg4 ;
80187   Dali::AlphaFunction *argp4 ;
80188
80189   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80190   arg2 = (Dali::Vector2 *)jarg2;
80191   if (!arg2) {
80192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80193     return ;
80194   }
80195   arg3 = (float)jarg3;
80196   argp4 = (Dali::AlphaFunction *)jarg4;
80197   if (!argp4) {
80198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80199     return ;
80200   }
80201   arg4 = *argp4;
80202   {
80203     try {
80204       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
80205     } catch (std::out_of_range& e) {
80206       {
80207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80208       };
80209     } catch (std::exception& e) {
80210       {
80211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80212       };
80213     } catch (Dali::DaliException e) {
80214       {
80215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80216       };
80217     } catch (...) {
80218       {
80219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80220       };
80221     }
80222   }
80223
80224 }
80225
80226
80227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
80228   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80229   Dali::Vector2 *arg2 = 0 ;
80230   float arg3 ;
80231   Dali::Toolkit::DirectionBias arg4 ;
80232   Dali::Toolkit::DirectionBias arg5 ;
80233
80234   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80235   arg2 = (Dali::Vector2 *)jarg2;
80236   if (!arg2) {
80237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80238     return ;
80239   }
80240   arg3 = (float)jarg3;
80241   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80242   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80243   {
80244     try {
80245       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
80246     } catch (std::out_of_range& e) {
80247       {
80248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80249       };
80250     } catch (std::exception& e) {
80251       {
80252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80253       };
80254     } catch (Dali::DaliException e) {
80255       {
80256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80257       };
80258     } catch (...) {
80259       {
80260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80261       };
80262     }
80263   }
80264
80265 }
80266
80267
80268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
80269   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80270   Dali::Vector2 *arg2 = 0 ;
80271   float arg3 ;
80272   Dali::AlphaFunction arg4 ;
80273   Dali::Toolkit::DirectionBias arg5 ;
80274   Dali::Toolkit::DirectionBias arg6 ;
80275   Dali::AlphaFunction *argp4 ;
80276
80277   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80278   arg2 = (Dali::Vector2 *)jarg2;
80279   if (!arg2) {
80280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80281     return ;
80282   }
80283   arg3 = (float)jarg3;
80284   argp4 = (Dali::AlphaFunction *)jarg4;
80285   if (!argp4) {
80286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80287     return ;
80288   }
80289   arg4 = *argp4;
80290   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80291   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
80292   {
80293     try {
80294       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
80295     } catch (std::out_of_range& e) {
80296       {
80297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80298       };
80299     } catch (std::exception& e) {
80300       {
80301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80302       };
80303     } catch (Dali::DaliException e) {
80304       {
80305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80306       };
80307     } catch (...) {
80308       {
80309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80310       };
80311     }
80312   }
80313
80314 }
80315
80316
80317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
80318   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80319   unsigned int arg2 ;
80320
80321   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80322   arg2 = (unsigned int)jarg2;
80323   {
80324     try {
80325       (arg1)->ScrollTo(arg2);
80326     } catch (std::out_of_range& e) {
80327       {
80328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80329       };
80330     } catch (std::exception& e) {
80331       {
80332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80333       };
80334     } catch (Dali::DaliException e) {
80335       {
80336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80337       };
80338     } catch (...) {
80339       {
80340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80341       };
80342     }
80343   }
80344
80345 }
80346
80347
80348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
80349   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80350   unsigned int arg2 ;
80351   float arg3 ;
80352
80353   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80354   arg2 = (unsigned int)jarg2;
80355   arg3 = (float)jarg3;
80356   {
80357     try {
80358       (arg1)->ScrollTo(arg2,arg3);
80359     } catch (std::out_of_range& e) {
80360       {
80361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80362       };
80363     } catch (std::exception& e) {
80364       {
80365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80366       };
80367     } catch (Dali::DaliException e) {
80368       {
80369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80370       };
80371     } catch (...) {
80372       {
80373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80374       };
80375     }
80376   }
80377
80378 }
80379
80380
80381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
80382   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80383   unsigned int arg2 ;
80384   float arg3 ;
80385   Dali::Toolkit::DirectionBias arg4 ;
80386
80387   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80388   arg2 = (unsigned int)jarg2;
80389   arg3 = (float)jarg3;
80390   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80391   {
80392     try {
80393       (arg1)->ScrollTo(arg2,arg3,arg4);
80394     } catch (std::out_of_range& e) {
80395       {
80396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80397       };
80398     } catch (std::exception& e) {
80399       {
80400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80401       };
80402     } catch (Dali::DaliException e) {
80403       {
80404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80405       };
80406     } catch (...) {
80407       {
80408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80409       };
80410     }
80411   }
80412
80413 }
80414
80415
80416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
80417   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80418   Dali::Actor *arg2 = 0 ;
80419
80420   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80421   arg2 = (Dali::Actor *)jarg2;
80422   if (!arg2) {
80423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80424     return ;
80425   }
80426   {
80427     try {
80428       (arg1)->ScrollTo(*arg2);
80429     } catch (std::out_of_range& e) {
80430       {
80431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80432       };
80433     } catch (std::exception& e) {
80434       {
80435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80436       };
80437     } catch (Dali::DaliException e) {
80438       {
80439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80440       };
80441     } catch (...) {
80442       {
80443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80444       };
80445     }
80446   }
80447
80448 }
80449
80450
80451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
80452   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80453   Dali::Actor *arg2 = 0 ;
80454   float arg3 ;
80455
80456   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80457   arg2 = (Dali::Actor *)jarg2;
80458   if (!arg2) {
80459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80460     return ;
80461   }
80462   arg3 = (float)jarg3;
80463   {
80464     try {
80465       (arg1)->ScrollTo(*arg2,arg3);
80466     } catch (std::out_of_range& e) {
80467       {
80468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80469       };
80470     } catch (std::exception& e) {
80471       {
80472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80473       };
80474     } catch (Dali::DaliException e) {
80475       {
80476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80477       };
80478     } catch (...) {
80479       {
80480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80481       };
80482     }
80483   }
80484
80485 }
80486
80487
80488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
80489   unsigned int jresult ;
80490   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80491   bool result;
80492
80493   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80494   {
80495     try {
80496       result = (bool)(arg1)->ScrollToSnapPoint();
80497     } catch (std::out_of_range& e) {
80498       {
80499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80500       };
80501     } catch (std::exception& e) {
80502       {
80503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80504       };
80505     } catch (Dali::DaliException e) {
80506       {
80507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80508       };
80509     } catch (...) {
80510       {
80511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80512       };
80513     }
80514   }
80515
80516   jresult = result;
80517   return jresult;
80518 }
80519
80520
80521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
80522   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80523   Dali::Constraint arg2 ;
80524   Dali::Constraint *argp2 ;
80525
80526   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80527   argp2 = (Dali::Constraint *)jarg2;
80528   if (!argp2) {
80529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
80530     return ;
80531   }
80532   arg2 = *argp2;
80533   {
80534     try {
80535       (arg1)->ApplyConstraintToChildren(arg2);
80536     } catch (std::out_of_range& e) {
80537       {
80538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80539       };
80540     } catch (std::exception& e) {
80541       {
80542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80543       };
80544     } catch (Dali::DaliException e) {
80545       {
80546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80547       };
80548     } catch (...) {
80549       {
80550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80551       };
80552     }
80553   }
80554
80555 }
80556
80557
80558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
80559   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80560
80561   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80562   {
80563     try {
80564       (arg1)->RemoveConstraintsFromChildren();
80565     } catch (std::out_of_range& e) {
80566       {
80567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80568       };
80569     } catch (std::exception& e) {
80570       {
80571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80572       };
80573     } catch (Dali::DaliException e) {
80574       {
80575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80576       };
80577     } catch (...) {
80578       {
80579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80580       };
80581     }
80582   }
80583
80584 }
80585
80586
80587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
80588   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80589   Dali::Toolkit::ScrollViewEffect arg2 ;
80590   Dali::Toolkit::ScrollViewEffect *argp2 ;
80591
80592   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80593   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80594   if (!argp2) {
80595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80596     return ;
80597   }
80598   arg2 = *argp2;
80599   {
80600     try {
80601       (arg1)->ApplyEffect(arg2);
80602     } catch (std::out_of_range& e) {
80603       {
80604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80605       };
80606     } catch (std::exception& e) {
80607       {
80608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80609       };
80610     } catch (Dali::DaliException e) {
80611       {
80612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80613       };
80614     } catch (...) {
80615       {
80616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80617       };
80618     }
80619   }
80620
80621 }
80622
80623
80624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
80625   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80626   Dali::Toolkit::ScrollViewEffect arg2 ;
80627   Dali::Toolkit::ScrollViewEffect *argp2 ;
80628
80629   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80630   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80631   if (!argp2) {
80632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80633     return ;
80634   }
80635   arg2 = *argp2;
80636   {
80637     try {
80638       (arg1)->RemoveEffect(arg2);
80639     } catch (std::out_of_range& e) {
80640       {
80641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80642       };
80643     } catch (std::exception& e) {
80644       {
80645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80646       };
80647     } catch (Dali::DaliException e) {
80648       {
80649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80650       };
80651     } catch (...) {
80652       {
80653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80654       };
80655     }
80656   }
80657
80658 }
80659
80660
80661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
80662   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80663
80664   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80665   {
80666     try {
80667       (arg1)->RemoveAllEffects();
80668     } catch (std::out_of_range& e) {
80669       {
80670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80671       };
80672     } catch (std::exception& e) {
80673       {
80674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80675       };
80676     } catch (Dali::DaliException e) {
80677       {
80678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80679       };
80680     } catch (...) {
80681       {
80682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80683       };
80684     }
80685   }
80686
80687 }
80688
80689
80690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
80691   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80692   Dali::Actor arg2 ;
80693   Dali::Actor *argp2 ;
80694
80695   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80696   argp2 = (Dali::Actor *)jarg2;
80697   if (!argp2) {
80698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80699     return ;
80700   }
80701   arg2 = *argp2;
80702   {
80703     try {
80704       (arg1)->BindActor(arg2);
80705     } catch (std::out_of_range& e) {
80706       {
80707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80708       };
80709     } catch (std::exception& e) {
80710       {
80711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80712       };
80713     } catch (Dali::DaliException e) {
80714       {
80715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80716       };
80717     } catch (...) {
80718       {
80719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80720       };
80721     }
80722   }
80723
80724 }
80725
80726
80727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
80728   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80729   Dali::Actor arg2 ;
80730   Dali::Actor *argp2 ;
80731
80732   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80733   argp2 = (Dali::Actor *)jarg2;
80734   if (!argp2) {
80735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80736     return ;
80737   }
80738   arg2 = *argp2;
80739   {
80740     try {
80741       (arg1)->UnbindActor(arg2);
80742     } catch (std::out_of_range& e) {
80743       {
80744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80745       };
80746     } catch (std::exception& e) {
80747       {
80748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80749       };
80750     } catch (Dali::DaliException e) {
80751       {
80752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80753       };
80754     } catch (...) {
80755       {
80756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80757       };
80758     }
80759   }
80760
80761 }
80762
80763
80764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
80765   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80766   Dali::Radian arg2 ;
80767   Dali::Radian arg3 ;
80768   Dali::Radian *argp2 ;
80769   Dali::Radian *argp3 ;
80770
80771   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80772   argp2 = (Dali::Radian *)jarg2;
80773   if (!argp2) {
80774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80775     return ;
80776   }
80777   arg2 = *argp2;
80778   argp3 = (Dali::Radian *)jarg3;
80779   if (!argp3) {
80780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80781     return ;
80782   }
80783   arg3 = *argp3;
80784   {
80785     try {
80786       (arg1)->SetScrollingDirection(arg2,arg3);
80787     } catch (std::out_of_range& e) {
80788       {
80789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80790       };
80791     } catch (std::exception& e) {
80792       {
80793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80794       };
80795     } catch (Dali::DaliException e) {
80796       {
80797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80798       };
80799     } catch (...) {
80800       {
80801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80802       };
80803     }
80804   }
80805
80806 }
80807
80808
80809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
80810   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80811   Dali::Radian arg2 ;
80812   Dali::Radian *argp2 ;
80813
80814   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80815   argp2 = (Dali::Radian *)jarg2;
80816   if (!argp2) {
80817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80818     return ;
80819   }
80820   arg2 = *argp2;
80821   {
80822     try {
80823       (arg1)->SetScrollingDirection(arg2);
80824     } catch (std::out_of_range& e) {
80825       {
80826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80827       };
80828     } catch (std::exception& e) {
80829       {
80830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80831       };
80832     } catch (Dali::DaliException e) {
80833       {
80834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80835       };
80836     } catch (...) {
80837       {
80838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80839       };
80840     }
80841   }
80842
80843 }
80844
80845
80846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
80847   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80848   Dali::Radian arg2 ;
80849   Dali::Radian *argp2 ;
80850
80851   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80852   argp2 = (Dali::Radian *)jarg2;
80853   if (!argp2) {
80854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80855     return ;
80856   }
80857   arg2 = *argp2;
80858   {
80859     try {
80860       (arg1)->RemoveScrollingDirection(arg2);
80861     } catch (std::out_of_range& e) {
80862       {
80863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80864       };
80865     } catch (std::exception& e) {
80866       {
80867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80868       };
80869     } catch (Dali::DaliException e) {
80870       {
80871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80872       };
80873     } catch (...) {
80874       {
80875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80876       };
80877     }
80878   }
80879
80880 }
80881
80882
80883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
80884   void * jresult ;
80885   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80886   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
80887
80888   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80889   {
80890     try {
80891       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
80892     } catch (std::out_of_range& e) {
80893       {
80894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80895       };
80896     } catch (std::exception& e) {
80897       {
80898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80899       };
80900     } catch (Dali::DaliException e) {
80901       {
80902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80903       };
80904     } catch (...) {
80905       {
80906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80907       };
80908     }
80909   }
80910
80911   jresult = (void *)result;
80912   return jresult;
80913 }
80914
80915
80916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
80917   int jresult ;
80918   int result;
80919
80920   result = (int)Dali::Toolkit::TableView::Property::ROWS;
80921   jresult = (int)result;
80922   return jresult;
80923 }
80924
80925
80926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
80927   int jresult ;
80928   int result;
80929
80930   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
80931   jresult = (int)result;
80932   return jresult;
80933 }
80934
80935
80936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
80937   int jresult ;
80938   int result;
80939
80940   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
80941   jresult = (int)result;
80942   return jresult;
80943 }
80944
80945
80946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
80947   int jresult ;
80948   int result;
80949
80950   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
80951   jresult = (int)result;
80952   return jresult;
80953 }
80954
80955
80956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
80957   int jresult ;
80958   int result;
80959
80960   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
80961   jresult = (int)result;
80962   return jresult;
80963 }
80964
80965
80966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
80967   void * jresult ;
80968   Dali::Toolkit::TableView::Property *result = 0 ;
80969
80970   {
80971     try {
80972       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
80973     } catch (std::out_of_range& e) {
80974       {
80975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80976       };
80977     } catch (std::exception& e) {
80978       {
80979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80980       };
80981     } catch (Dali::DaliException e) {
80982       {
80983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80984       };
80985     } catch (...) {
80986       {
80987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80988       };
80989     }
80990   }
80991
80992   jresult = (void *)result;
80993   return jresult;
80994 }
80995
80996
80997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
80998   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
80999
81000   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
81001   {
81002     try {
81003       delete arg1;
81004     } catch (std::out_of_range& e) {
81005       {
81006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81007       };
81008     } catch (std::exception& e) {
81009       {
81010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81011       };
81012     } catch (Dali::DaliException e) {
81013       {
81014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81015       };
81016     } catch (...) {
81017       {
81018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81019       };
81020     }
81021   }
81022
81023 }
81024
81025
81026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
81027   int jresult ;
81028   int result;
81029
81030   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
81031   jresult = (int)result;
81032   return jresult;
81033 }
81034
81035
81036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
81037   int jresult ;
81038   int result;
81039
81040   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
81041   jresult = (int)result;
81042   return jresult;
81043 }
81044
81045
81046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
81047   int jresult ;
81048   int result;
81049
81050   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
81051   jresult = (int)result;
81052   return jresult;
81053 }
81054
81055
81056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
81057   int jresult ;
81058   int result;
81059
81060   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
81061   jresult = (int)result;
81062   return jresult;
81063 }
81064
81065
81066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
81067   int jresult ;
81068   int result;
81069
81070   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
81071   jresult = (int)result;
81072   return jresult;
81073 }
81074
81075
81076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
81077   void * jresult ;
81078   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
81079
81080   {
81081     try {
81082       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
81083     } catch (std::out_of_range& e) {
81084       {
81085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81086       };
81087     } catch (std::exception& e) {
81088       {
81089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81090       };
81091     } catch (Dali::DaliException e) {
81092       {
81093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81094       };
81095     } catch (...) {
81096       {
81097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81098       };
81099     }
81100   }
81101
81102   jresult = (void *)result;
81103   return jresult;
81104 }
81105
81106
81107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
81108   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
81109
81110   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
81111   {
81112     try {
81113       delete arg1;
81114     } catch (std::out_of_range& e) {
81115       {
81116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81117       };
81118     } catch (std::exception& e) {
81119       {
81120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81121       };
81122     } catch (Dali::DaliException e) {
81123       {
81124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81125       };
81126     } catch (...) {
81127       {
81128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81129       };
81130     }
81131   }
81132
81133 }
81134
81135
81136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
81137   void * jresult ;
81138   unsigned int arg1 ;
81139   unsigned int arg2 ;
81140   unsigned int arg3 ;
81141   unsigned int arg4 ;
81142   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81143
81144   arg1 = (unsigned int)jarg1;
81145   arg2 = (unsigned int)jarg2;
81146   arg3 = (unsigned int)jarg3;
81147   arg4 = (unsigned int)jarg4;
81148   {
81149     try {
81150       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
81151     } catch (std::out_of_range& e) {
81152       {
81153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81154       };
81155     } catch (std::exception& e) {
81156       {
81157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81158       };
81159     } catch (Dali::DaliException e) {
81160       {
81161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81162       };
81163     } catch (...) {
81164       {
81165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81166       };
81167     }
81168   }
81169
81170   jresult = (void *)result;
81171   return jresult;
81172 }
81173
81174
81175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
81176   void * jresult ;
81177   unsigned int arg1 ;
81178   unsigned int arg2 ;
81179   unsigned int arg3 ;
81180   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81181
81182   arg1 = (unsigned int)jarg1;
81183   arg2 = (unsigned int)jarg2;
81184   arg3 = (unsigned int)jarg3;
81185   {
81186     try {
81187       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
81188     } catch (std::out_of_range& e) {
81189       {
81190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81191       };
81192     } catch (std::exception& e) {
81193       {
81194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81195       };
81196     } catch (Dali::DaliException e) {
81197       {
81198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81199       };
81200     } catch (...) {
81201       {
81202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81203       };
81204     }
81205   }
81206
81207   jresult = (void *)result;
81208   return jresult;
81209 }
81210
81211
81212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
81213   void * jresult ;
81214   unsigned int arg1 ;
81215   unsigned int arg2 ;
81216   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81217
81218   arg1 = (unsigned int)jarg1;
81219   arg2 = (unsigned int)jarg2;
81220   {
81221     try {
81222       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
81223     } catch (std::out_of_range& e) {
81224       {
81225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81226       };
81227     } catch (std::exception& e) {
81228       {
81229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81230       };
81231     } catch (Dali::DaliException e) {
81232       {
81233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81234       };
81235     } catch (...) {
81236       {
81237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81238       };
81239     }
81240   }
81241
81242   jresult = (void *)result;
81243   return jresult;
81244 }
81245
81246
81247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
81248   void * jresult ;
81249   unsigned int arg1 ;
81250   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81251
81252   arg1 = (unsigned int)jarg1;
81253   {
81254     try {
81255       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
81256     } catch (std::out_of_range& e) {
81257       {
81258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81259       };
81260     } catch (std::exception& e) {
81261       {
81262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81263       };
81264     } catch (Dali::DaliException e) {
81265       {
81266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81267       };
81268     } catch (...) {
81269       {
81270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81271       };
81272     }
81273   }
81274
81275   jresult = (void *)result;
81276   return jresult;
81277 }
81278
81279
81280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
81281   void * jresult ;
81282   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81283
81284   {
81285     try {
81286       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
81287     } catch (std::out_of_range& e) {
81288       {
81289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81290       };
81291     } catch (std::exception& e) {
81292       {
81293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81294       };
81295     } catch (Dali::DaliException e) {
81296       {
81297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81298       };
81299     } catch (...) {
81300       {
81301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81302       };
81303     }
81304   }
81305
81306   jresult = (void *)result;
81307   return jresult;
81308 }
81309
81310
81311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
81312   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81313   unsigned int arg2 ;
81314
81315   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81316   arg2 = (unsigned int)jarg2;
81317   if (arg1) (arg1)->rowIndex = arg2;
81318 }
81319
81320
81321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
81322   unsigned int jresult ;
81323   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81324   unsigned int result;
81325
81326   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81327   result = (unsigned int) ((arg1)->rowIndex);
81328   jresult = result;
81329   return jresult;
81330 }
81331
81332
81333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
81334   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81335   unsigned int arg2 ;
81336
81337   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81338   arg2 = (unsigned int)jarg2;
81339   if (arg1) (arg1)->columnIndex = arg2;
81340 }
81341
81342
81343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
81344   unsigned int jresult ;
81345   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81346   unsigned int result;
81347
81348   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81349   result = (unsigned int) ((arg1)->columnIndex);
81350   jresult = result;
81351   return jresult;
81352 }
81353
81354
81355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
81356   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81357   unsigned int arg2 ;
81358
81359   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81360   arg2 = (unsigned int)jarg2;
81361   if (arg1) (arg1)->rowSpan = arg2;
81362 }
81363
81364
81365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
81366   unsigned int jresult ;
81367   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81368   unsigned int result;
81369
81370   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81371   result = (unsigned int) ((arg1)->rowSpan);
81372   jresult = result;
81373   return jresult;
81374 }
81375
81376
81377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
81378   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81379   unsigned int arg2 ;
81380
81381   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81382   arg2 = (unsigned int)jarg2;
81383   if (arg1) (arg1)->columnSpan = arg2;
81384 }
81385
81386
81387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
81388   unsigned int jresult ;
81389   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81390   unsigned int result;
81391
81392   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81393   result = (unsigned int) ((arg1)->columnSpan);
81394   jresult = result;
81395   return jresult;
81396 }
81397
81398
81399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
81400   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81401
81402   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81403   {
81404     try {
81405       delete arg1;
81406     } catch (std::out_of_range& e) {
81407       {
81408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81409       };
81410     } catch (std::exception& e) {
81411       {
81412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81413       };
81414     } catch (Dali::DaliException e) {
81415       {
81416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81417       };
81418     } catch (...) {
81419       {
81420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81421       };
81422     }
81423   }
81424
81425 }
81426
81427
81428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
81429   void * jresult ;
81430   Dali::Toolkit::TableView *result = 0 ;
81431
81432   {
81433     try {
81434       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
81435     } catch (std::out_of_range& e) {
81436       {
81437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81438       };
81439     } catch (std::exception& e) {
81440       {
81441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81442       };
81443     } catch (Dali::DaliException e) {
81444       {
81445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81446       };
81447     } catch (...) {
81448       {
81449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81450       };
81451     }
81452   }
81453
81454   jresult = (void *)result;
81455   return jresult;
81456 }
81457
81458
81459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
81460   void * jresult ;
81461   Dali::Toolkit::TableView *arg1 = 0 ;
81462   Dali::Toolkit::TableView *result = 0 ;
81463
81464   arg1 = (Dali::Toolkit::TableView *)jarg1;
81465   if (!arg1) {
81466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81467     return 0;
81468   }
81469   {
81470     try {
81471       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
81472     } catch (std::out_of_range& e) {
81473       {
81474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81475       };
81476     } catch (std::exception& e) {
81477       {
81478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81479       };
81480     } catch (Dali::DaliException e) {
81481       {
81482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81483       };
81484     } catch (...) {
81485       {
81486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81487       };
81488     }
81489   }
81490
81491   jresult = (void *)result;
81492   return jresult;
81493 }
81494
81495
81496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
81497   void * jresult ;
81498   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81499   Dali::Toolkit::TableView *arg2 = 0 ;
81500   Dali::Toolkit::TableView *result = 0 ;
81501
81502   arg1 = (Dali::Toolkit::TableView *)jarg1;
81503   arg2 = (Dali::Toolkit::TableView *)jarg2;
81504   if (!arg2) {
81505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81506     return 0;
81507   }
81508   {
81509     try {
81510       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
81511     } catch (std::out_of_range& e) {
81512       {
81513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81514       };
81515     } catch (std::exception& e) {
81516       {
81517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81518       };
81519     } catch (Dali::DaliException e) {
81520       {
81521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81522       };
81523     } catch (...) {
81524       {
81525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81526       };
81527     }
81528   }
81529
81530   jresult = (void *)result;
81531   return jresult;
81532 }
81533
81534
81535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
81536   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81537
81538   arg1 = (Dali::Toolkit::TableView *)jarg1;
81539   {
81540     try {
81541       delete arg1;
81542     } catch (std::out_of_range& e) {
81543       {
81544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81545       };
81546     } catch (std::exception& e) {
81547       {
81548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81549       };
81550     } catch (Dali::DaliException e) {
81551       {
81552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81553       };
81554     } catch (...) {
81555       {
81556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81557       };
81558     }
81559   }
81560
81561 }
81562
81563
81564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
81565   void * jresult ;
81566   unsigned int arg1 ;
81567   unsigned int arg2 ;
81568   Dali::Toolkit::TableView result;
81569
81570   arg1 = (unsigned int)jarg1;
81571   arg2 = (unsigned int)jarg2;
81572   {
81573     try {
81574       result = Dali::Toolkit::TableView::New(arg1,arg2);
81575     } catch (std::out_of_range& e) {
81576       {
81577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81578       };
81579     } catch (std::exception& e) {
81580       {
81581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81582       };
81583     } catch (Dali::DaliException e) {
81584       {
81585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81586       };
81587     } catch (...) {
81588       {
81589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81590       };
81591     }
81592   }
81593
81594   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81595   return jresult;
81596 }
81597
81598
81599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
81600   void * jresult ;
81601   Dali::BaseHandle arg1 ;
81602   Dali::BaseHandle *argp1 ;
81603   Dali::Toolkit::TableView result;
81604
81605   argp1 = (Dali::BaseHandle *)jarg1;
81606   if (!argp1) {
81607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81608     return 0;
81609   }
81610   arg1 = *argp1;
81611   {
81612     try {
81613       result = Dali::Toolkit::TableView::DownCast(arg1);
81614     } catch (std::out_of_range& e) {
81615       {
81616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81617       };
81618     } catch (std::exception& e) {
81619       {
81620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81621       };
81622     } catch (Dali::DaliException e) {
81623       {
81624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81625       };
81626     } catch (...) {
81627       {
81628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81629       };
81630     }
81631   }
81632
81633   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81634   return jresult;
81635 }
81636
81637
81638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
81639   unsigned int jresult ;
81640   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81641   Dali::Actor arg2 ;
81642   Dali::Toolkit::TableView::CellPosition arg3 ;
81643   Dali::Actor *argp2 ;
81644   Dali::Toolkit::TableView::CellPosition *argp3 ;
81645   bool result;
81646
81647   arg1 = (Dali::Toolkit::TableView *)jarg1;
81648   argp2 = (Dali::Actor *)jarg2;
81649   if (!argp2) {
81650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81651     return 0;
81652   }
81653   arg2 = *argp2;
81654   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81655   if (!argp3) {
81656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81657     return 0;
81658   }
81659   arg3 = *argp3;
81660   {
81661     try {
81662       result = (bool)(arg1)->AddChild(arg2,arg3);
81663     } catch (std::out_of_range& e) {
81664       {
81665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81666       };
81667     } catch (std::exception& e) {
81668       {
81669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81670       };
81671     } catch (Dali::DaliException e) {
81672       {
81673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81674       };
81675     } catch (...) {
81676       {
81677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81678       };
81679     }
81680   }
81681
81682   jresult = result;
81683   return jresult;
81684 }
81685
81686
81687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
81688   void * jresult ;
81689   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81690   Dali::Toolkit::TableView::CellPosition arg2 ;
81691   Dali::Toolkit::TableView::CellPosition *argp2 ;
81692   Dali::Actor result;
81693
81694   arg1 = (Dali::Toolkit::TableView *)jarg1;
81695   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81696   if (!argp2) {
81697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81698     return 0;
81699   }
81700   arg2 = *argp2;
81701   {
81702     try {
81703       result = (arg1)->GetChildAt(arg2);
81704     } catch (std::out_of_range& e) {
81705       {
81706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81707       };
81708     } catch (std::exception& e) {
81709       {
81710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81711       };
81712     } catch (Dali::DaliException e) {
81713       {
81714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81715       };
81716     } catch (...) {
81717       {
81718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81719       };
81720     }
81721   }
81722
81723   jresult = new Dali::Actor((const Dali::Actor &)result);
81724   return jresult;
81725 }
81726
81727
81728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
81729   void * jresult ;
81730   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81731   Dali::Toolkit::TableView::CellPosition arg2 ;
81732   Dali::Toolkit::TableView::CellPosition *argp2 ;
81733   Dali::Actor result;
81734
81735   arg1 = (Dali::Toolkit::TableView *)jarg1;
81736   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81737   if (!argp2) {
81738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81739     return 0;
81740   }
81741   arg2 = *argp2;
81742   {
81743     try {
81744       result = (arg1)->RemoveChildAt(arg2);
81745     } catch (std::out_of_range& e) {
81746       {
81747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81748       };
81749     } catch (std::exception& e) {
81750       {
81751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81752       };
81753     } catch (Dali::DaliException e) {
81754       {
81755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81756       };
81757     } catch (...) {
81758       {
81759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81760       };
81761     }
81762   }
81763
81764   jresult = new Dali::Actor((const Dali::Actor &)result);
81765   return jresult;
81766 }
81767
81768
81769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
81770   unsigned int jresult ;
81771   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81772   Dali::Actor arg2 ;
81773   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
81774   Dali::Actor *argp2 ;
81775   bool result;
81776
81777   arg1 = (Dali::Toolkit::TableView *)jarg1;
81778   argp2 = (Dali::Actor *)jarg2;
81779   if (!argp2) {
81780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81781     return 0;
81782   }
81783   arg2 = *argp2;
81784   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81785   if (!arg3) {
81786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
81787     return 0;
81788   }
81789   {
81790     try {
81791       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
81792     } catch (std::out_of_range& e) {
81793       {
81794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81795       };
81796     } catch (std::exception& e) {
81797       {
81798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81799       };
81800     } catch (Dali::DaliException e) {
81801       {
81802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81803       };
81804     } catch (...) {
81805       {
81806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81807       };
81808     }
81809   }
81810
81811   jresult = result;
81812   return jresult;
81813 }
81814
81815
81816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
81817   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81818   unsigned int arg2 ;
81819
81820   arg1 = (Dali::Toolkit::TableView *)jarg1;
81821   arg2 = (unsigned int)jarg2;
81822   {
81823     try {
81824       (arg1)->InsertRow(arg2);
81825     } catch (std::out_of_range& e) {
81826       {
81827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81828       };
81829     } catch (std::exception& e) {
81830       {
81831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81832       };
81833     } catch (Dali::DaliException e) {
81834       {
81835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81836       };
81837     } catch (...) {
81838       {
81839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81840       };
81841     }
81842   }
81843
81844 }
81845
81846
81847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
81848   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81849   unsigned int arg2 ;
81850
81851   arg1 = (Dali::Toolkit::TableView *)jarg1;
81852   arg2 = (unsigned int)jarg2;
81853   {
81854     try {
81855       (arg1)->DeleteRow(arg2);
81856     } catch (std::out_of_range& e) {
81857       {
81858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81859       };
81860     } catch (std::exception& e) {
81861       {
81862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81863       };
81864     } catch (Dali::DaliException e) {
81865       {
81866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81867       };
81868     } catch (...) {
81869       {
81870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81871       };
81872     }
81873   }
81874
81875 }
81876
81877
81878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
81879   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81880   unsigned int arg2 ;
81881   std::vector< Dali::Actor > *arg3 = 0 ;
81882
81883   arg1 = (Dali::Toolkit::TableView *)jarg1;
81884   arg2 = (unsigned int)jarg2;
81885   arg3 = (std::vector< Dali::Actor > *)jarg3;
81886   if (!arg3) {
81887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
81888     return ;
81889   }
81890   {
81891     try {
81892       (arg1)->DeleteRow(arg2,*arg3);
81893     } catch (std::out_of_range& e) {
81894       {
81895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81896       };
81897     } catch (std::exception& e) {
81898       {
81899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81900       };
81901     } catch (Dali::DaliException e) {
81902       {
81903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81904       };
81905     } catch (...) {
81906       {
81907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81908       };
81909     }
81910   }
81911
81912 }
81913
81914
81915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
81916   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81917   unsigned int arg2 ;
81918
81919   arg1 = (Dali::Toolkit::TableView *)jarg1;
81920   arg2 = (unsigned int)jarg2;
81921   {
81922     try {
81923       (arg1)->InsertColumn(arg2);
81924     } catch (std::out_of_range& e) {
81925       {
81926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81927       };
81928     } catch (std::exception& e) {
81929       {
81930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81931       };
81932     } catch (Dali::DaliException e) {
81933       {
81934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81935       };
81936     } catch (...) {
81937       {
81938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81939       };
81940     }
81941   }
81942
81943 }
81944
81945
81946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
81947   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81948   unsigned int arg2 ;
81949
81950   arg1 = (Dali::Toolkit::TableView *)jarg1;
81951   arg2 = (unsigned int)jarg2;
81952   {
81953     try {
81954       (arg1)->DeleteColumn(arg2);
81955     } catch (std::out_of_range& e) {
81956       {
81957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81958       };
81959     } catch (std::exception& e) {
81960       {
81961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81962       };
81963     } catch (Dali::DaliException e) {
81964       {
81965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81966       };
81967     } catch (...) {
81968       {
81969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81970       };
81971     }
81972   }
81973
81974 }
81975
81976
81977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
81978   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81979   unsigned int arg2 ;
81980   std::vector< Dali::Actor > *arg3 = 0 ;
81981
81982   arg1 = (Dali::Toolkit::TableView *)jarg1;
81983   arg2 = (unsigned int)jarg2;
81984   arg3 = (std::vector< Dali::Actor > *)jarg3;
81985   if (!arg3) {
81986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
81987     return ;
81988   }
81989   {
81990     try {
81991       (arg1)->DeleteColumn(arg2,*arg3);
81992     } catch (std::out_of_range& e) {
81993       {
81994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81995       };
81996     } catch (std::exception& e) {
81997       {
81998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81999       };
82000     } catch (Dali::DaliException e) {
82001       {
82002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82003       };
82004     } catch (...) {
82005       {
82006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82007       };
82008     }
82009   }
82010
82011 }
82012
82013
82014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
82015   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82016   unsigned int arg2 ;
82017   unsigned int arg3 ;
82018
82019   arg1 = (Dali::Toolkit::TableView *)jarg1;
82020   arg2 = (unsigned int)jarg2;
82021   arg3 = (unsigned int)jarg3;
82022   {
82023     try {
82024       (arg1)->Resize(arg2,arg3);
82025     } catch (std::out_of_range& e) {
82026       {
82027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82028       };
82029     } catch (std::exception& e) {
82030       {
82031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82032       };
82033     } catch (Dali::DaliException e) {
82034       {
82035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82036       };
82037     } catch (...) {
82038       {
82039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82040       };
82041     }
82042   }
82043
82044 }
82045
82046
82047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
82048   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82049   unsigned int arg2 ;
82050   unsigned int arg3 ;
82051   std::vector< Dali::Actor > *arg4 = 0 ;
82052
82053   arg1 = (Dali::Toolkit::TableView *)jarg1;
82054   arg2 = (unsigned int)jarg2;
82055   arg3 = (unsigned int)jarg3;
82056   arg4 = (std::vector< Dali::Actor > *)jarg4;
82057   if (!arg4) {
82058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82059     return ;
82060   }
82061   {
82062     try {
82063       (arg1)->Resize(arg2,arg3,*arg4);
82064     } catch (std::out_of_range& e) {
82065       {
82066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82067       };
82068     } catch (std::exception& e) {
82069       {
82070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82071       };
82072     } catch (Dali::DaliException e) {
82073       {
82074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82075       };
82076     } catch (...) {
82077       {
82078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82079       };
82080     }
82081   }
82082
82083 }
82084
82085
82086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
82087   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82088   Dali::Size arg2 ;
82089   Dali::Size *argp2 ;
82090
82091   arg1 = (Dali::Toolkit::TableView *)jarg1;
82092   argp2 = (Dali::Size *)jarg2;
82093   if (!argp2) {
82094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
82095     return ;
82096   }
82097   arg2 = *argp2;
82098   {
82099     try {
82100       (arg1)->SetCellPadding(arg2);
82101     } catch (std::out_of_range& e) {
82102       {
82103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82104       };
82105     } catch (std::exception& e) {
82106       {
82107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82108       };
82109     } catch (Dali::DaliException e) {
82110       {
82111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82112       };
82113     } catch (...) {
82114       {
82115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82116       };
82117     }
82118   }
82119
82120 }
82121
82122
82123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
82124   void * jresult ;
82125   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82126   Dali::Size result;
82127
82128   arg1 = (Dali::Toolkit::TableView *)jarg1;
82129   {
82130     try {
82131       result = (arg1)->GetCellPadding();
82132     } catch (std::out_of_range& e) {
82133       {
82134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82135       };
82136     } catch (std::exception& e) {
82137       {
82138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82139       };
82140     } catch (Dali::DaliException e) {
82141       {
82142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82143       };
82144     } catch (...) {
82145       {
82146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82147       };
82148     }
82149   }
82150
82151   jresult = new Dali::Size((const Dali::Size &)result);
82152   return jresult;
82153 }
82154
82155
82156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
82157   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82158   unsigned int arg2 ;
82159
82160   arg1 = (Dali::Toolkit::TableView *)jarg1;
82161   arg2 = (unsigned int)jarg2;
82162   {
82163     try {
82164       (arg1)->SetFitHeight(arg2);
82165     } catch (std::out_of_range& e) {
82166       {
82167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82168       };
82169     } catch (std::exception& e) {
82170       {
82171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82172       };
82173     } catch (Dali::DaliException e) {
82174       {
82175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82176       };
82177     } catch (...) {
82178       {
82179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82180       };
82181     }
82182   }
82183
82184 }
82185
82186
82187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
82188   unsigned int jresult ;
82189   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82190   unsigned int arg2 ;
82191   bool result;
82192
82193   arg1 = (Dali::Toolkit::TableView *)jarg1;
82194   arg2 = (unsigned int)jarg2;
82195   {
82196     try {
82197       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
82198     } catch (std::out_of_range& e) {
82199       {
82200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82201       };
82202     } catch (std::exception& e) {
82203       {
82204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82205       };
82206     } catch (Dali::DaliException e) {
82207       {
82208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82209       };
82210     } catch (...) {
82211       {
82212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82213       };
82214     }
82215   }
82216
82217   jresult = result;
82218   return jresult;
82219 }
82220
82221
82222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
82223   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82224   unsigned int arg2 ;
82225
82226   arg1 = (Dali::Toolkit::TableView *)jarg1;
82227   arg2 = (unsigned int)jarg2;
82228   {
82229     try {
82230       (arg1)->SetFitWidth(arg2);
82231     } catch (std::out_of_range& e) {
82232       {
82233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82234       };
82235     } catch (std::exception& e) {
82236       {
82237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82238       };
82239     } catch (Dali::DaliException e) {
82240       {
82241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82242       };
82243     } catch (...) {
82244       {
82245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82246       };
82247     }
82248   }
82249
82250 }
82251
82252
82253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
82254   unsigned int jresult ;
82255   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82256   unsigned int arg2 ;
82257   bool result;
82258
82259   arg1 = (Dali::Toolkit::TableView *)jarg1;
82260   arg2 = (unsigned int)jarg2;
82261   {
82262     try {
82263       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
82264     } catch (std::out_of_range& e) {
82265       {
82266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82267       };
82268     } catch (std::exception& e) {
82269       {
82270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82271       };
82272     } catch (Dali::DaliException e) {
82273       {
82274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82275       };
82276     } catch (...) {
82277       {
82278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82279       };
82280     }
82281   }
82282
82283   jresult = result;
82284   return jresult;
82285 }
82286
82287
82288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82289   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82290   unsigned int arg2 ;
82291   float arg3 ;
82292
82293   arg1 = (Dali::Toolkit::TableView *)jarg1;
82294   arg2 = (unsigned int)jarg2;
82295   arg3 = (float)jarg3;
82296   {
82297     try {
82298       (arg1)->SetFixedHeight(arg2,arg3);
82299     } catch (std::out_of_range& e) {
82300       {
82301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82302       };
82303     } catch (std::exception& e) {
82304       {
82305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82306       };
82307     } catch (Dali::DaliException e) {
82308       {
82309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82310       };
82311     } catch (...) {
82312       {
82313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82314       };
82315     }
82316   }
82317
82318 }
82319
82320
82321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
82322   float jresult ;
82323   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82324   unsigned int arg2 ;
82325   float result;
82326
82327   arg1 = (Dali::Toolkit::TableView *)jarg1;
82328   arg2 = (unsigned int)jarg2;
82329   {
82330     try {
82331       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
82332     } catch (std::out_of_range& e) {
82333       {
82334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82335       };
82336     } catch (std::exception& e) {
82337       {
82338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82339       };
82340     } catch (Dali::DaliException e) {
82341       {
82342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82343       };
82344     } catch (...) {
82345       {
82346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82347       };
82348     }
82349   }
82350
82351   jresult = result;
82352   return jresult;
82353 }
82354
82355
82356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82357   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82358   unsigned int arg2 ;
82359   float arg3 ;
82360
82361   arg1 = (Dali::Toolkit::TableView *)jarg1;
82362   arg2 = (unsigned int)jarg2;
82363   arg3 = (float)jarg3;
82364   {
82365     try {
82366       (arg1)->SetRelativeHeight(arg2,arg3);
82367     } catch (std::out_of_range& e) {
82368       {
82369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82370       };
82371     } catch (std::exception& e) {
82372       {
82373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82374       };
82375     } catch (Dali::DaliException e) {
82376       {
82377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82378       };
82379     } catch (...) {
82380       {
82381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82382       };
82383     }
82384   }
82385
82386 }
82387
82388
82389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
82390   float jresult ;
82391   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82392   unsigned int arg2 ;
82393   float result;
82394
82395   arg1 = (Dali::Toolkit::TableView *)jarg1;
82396   arg2 = (unsigned int)jarg2;
82397   {
82398     try {
82399       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
82400     } catch (std::out_of_range& e) {
82401       {
82402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82403       };
82404     } catch (std::exception& e) {
82405       {
82406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82407       };
82408     } catch (Dali::DaliException e) {
82409       {
82410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82411       };
82412     } catch (...) {
82413       {
82414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82415       };
82416     }
82417   }
82418
82419   jresult = result;
82420   return jresult;
82421 }
82422
82423
82424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82425   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82426   unsigned int arg2 ;
82427   float arg3 ;
82428
82429   arg1 = (Dali::Toolkit::TableView *)jarg1;
82430   arg2 = (unsigned int)jarg2;
82431   arg3 = (float)jarg3;
82432   {
82433     try {
82434       (arg1)->SetFixedWidth(arg2,arg3);
82435     } catch (std::out_of_range& e) {
82436       {
82437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82438       };
82439     } catch (std::exception& e) {
82440       {
82441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82442       };
82443     } catch (Dali::DaliException e) {
82444       {
82445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82446       };
82447     } catch (...) {
82448       {
82449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82450       };
82451     }
82452   }
82453
82454 }
82455
82456
82457 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
82458   float jresult ;
82459   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82460   unsigned int arg2 ;
82461   float result;
82462
82463   arg1 = (Dali::Toolkit::TableView *)jarg1;
82464   arg2 = (unsigned int)jarg2;
82465   {
82466     try {
82467       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
82468     } catch (std::out_of_range& e) {
82469       {
82470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82471       };
82472     } catch (std::exception& e) {
82473       {
82474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82475       };
82476     } catch (Dali::DaliException e) {
82477       {
82478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82479       };
82480     } catch (...) {
82481       {
82482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82483       };
82484     }
82485   }
82486
82487   jresult = result;
82488   return jresult;
82489 }
82490
82491
82492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82493   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82494   unsigned int arg2 ;
82495   float arg3 ;
82496
82497   arg1 = (Dali::Toolkit::TableView *)jarg1;
82498   arg2 = (unsigned int)jarg2;
82499   arg3 = (float)jarg3;
82500   {
82501     try {
82502       (arg1)->SetRelativeWidth(arg2,arg3);
82503     } catch (std::out_of_range& e) {
82504       {
82505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82506       };
82507     } catch (std::exception& e) {
82508       {
82509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82510       };
82511     } catch (Dali::DaliException e) {
82512       {
82513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82514       };
82515     } catch (...) {
82516       {
82517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82518       };
82519     }
82520   }
82521
82522 }
82523
82524
82525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
82526   float jresult ;
82527   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82528   unsigned int arg2 ;
82529   float result;
82530
82531   arg1 = (Dali::Toolkit::TableView *)jarg1;
82532   arg2 = (unsigned int)jarg2;
82533   {
82534     try {
82535       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
82536     } catch (std::out_of_range& e) {
82537       {
82538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82539       };
82540     } catch (std::exception& e) {
82541       {
82542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82543       };
82544     } catch (Dali::DaliException e) {
82545       {
82546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82547       };
82548     } catch (...) {
82549       {
82550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82551       };
82552     }
82553   }
82554
82555   jresult = result;
82556   return jresult;
82557 }
82558
82559
82560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
82561   unsigned int jresult ;
82562   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82563   unsigned int result;
82564
82565   arg1 = (Dali::Toolkit::TableView *)jarg1;
82566   {
82567     try {
82568       result = (unsigned int)(arg1)->GetRows();
82569     } catch (std::out_of_range& e) {
82570       {
82571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82572       };
82573     } catch (std::exception& e) {
82574       {
82575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82576       };
82577     } catch (Dali::DaliException e) {
82578       {
82579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82580       };
82581     } catch (...) {
82582       {
82583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82584       };
82585     }
82586   }
82587
82588   jresult = result;
82589   return jresult;
82590 }
82591
82592
82593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
82594   unsigned int jresult ;
82595   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82596   unsigned int result;
82597
82598   arg1 = (Dali::Toolkit::TableView *)jarg1;
82599   {
82600     try {
82601       result = (unsigned int)(arg1)->GetColumns();
82602     } catch (std::out_of_range& e) {
82603       {
82604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82605       };
82606     } catch (std::exception& e) {
82607       {
82608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82609       };
82610     } catch (Dali::DaliException e) {
82611       {
82612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82613       };
82614     } catch (...) {
82615       {
82616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82617       };
82618     }
82619   }
82620
82621   jresult = result;
82622   return jresult;
82623 }
82624
82625
82626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
82627   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82628   Dali::Toolkit::TableView::CellPosition arg2 ;
82629   Dali::HorizontalAlignment::Type arg3 ;
82630   Dali::VerticalAlignment::Type arg4 ;
82631   Dali::Toolkit::TableView::CellPosition *argp2 ;
82632
82633   arg1 = (Dali::Toolkit::TableView *)jarg1;
82634   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82635   if (!argp2) {
82636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82637     return ;
82638   }
82639   arg2 = *argp2;
82640   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
82641   arg4 = (Dali::VerticalAlignment::Type)jarg4;
82642   {
82643     try {
82644       (arg1)->SetCellAlignment(arg2,arg3,arg4);
82645     } catch (std::out_of_range& e) {
82646       {
82647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82648       };
82649     } catch (std::exception& e) {
82650       {
82651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82652       };
82653     } catch (Dali::DaliException e) {
82654       {
82655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82656       };
82657     } catch (...) {
82658       {
82659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82660       };
82661     }
82662   }
82663
82664 }
82665
82666
82667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
82668   unsigned int jresult ;
82669   unsigned int result;
82670
82671   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
82672   jresult = result;
82673   return jresult;
82674 }
82675
82676
82677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
82678   int jresult ;
82679   int result;
82680
82681   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
82682   jresult = (int)result;
82683   return jresult;
82684 }
82685
82686
82687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
82688   int jresult ;
82689   int result;
82690
82691   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
82692   jresult = (int)result;
82693   return jresult;
82694 }
82695
82696
82697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
82698   int jresult ;
82699   int result;
82700
82701   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
82702   jresult = (int)result;
82703   return jresult;
82704 }
82705
82706
82707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
82708   int jresult ;
82709   int result;
82710
82711   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
82712   jresult = (int)result;
82713   return jresult;
82714 }
82715
82716
82717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
82718   int jresult ;
82719   int result;
82720
82721   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
82722   jresult = (int)result;
82723   return jresult;
82724 }
82725
82726
82727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
82728   int jresult ;
82729   int result;
82730
82731   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
82732   jresult = (int)result;
82733   return jresult;
82734 }
82735
82736
82737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
82738   int jresult ;
82739   int result;
82740
82741   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
82742   jresult = (int)result;
82743   return jresult;
82744 }
82745
82746
82747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
82748   int jresult ;
82749   int result;
82750
82751   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
82752   jresult = (int)result;
82753   return jresult;
82754 }
82755
82756
82757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
82758   int jresult ;
82759   int result;
82760
82761   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
82762   jresult = (int)result;
82763   return jresult;
82764 }
82765
82766
82767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
82768   int jresult ;
82769   int result;
82770
82771   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
82772   jresult = (int)result;
82773   return jresult;
82774 }
82775
82776
82777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
82778   int jresult ;
82779   int result;
82780
82781   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
82782   jresult = (int)result;
82783   return jresult;
82784 }
82785
82786
82787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
82788   int jresult ;
82789   int result;
82790
82791   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
82792   jresult = (int)result;
82793   return jresult;
82794 }
82795
82796
82797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
82798   int jresult ;
82799   int result;
82800
82801   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
82802   jresult = (int)result;
82803   return jresult;
82804 }
82805
82806
82807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
82808   int jresult ;
82809   int result;
82810
82811   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
82812   jresult = (int)result;
82813   return jresult;
82814 }
82815
82816
82817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
82818   int jresult ;
82819   int result;
82820
82821   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
82822   jresult = (int)result;
82823   return jresult;
82824 }
82825
82826
82827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
82828   int jresult ;
82829   int result;
82830
82831   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
82832   jresult = (int)result;
82833   return jresult;
82834 }
82835
82836
82837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
82838   int jresult ;
82839   int result;
82840
82841   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
82842   jresult = (int)result;
82843   return jresult;
82844 }
82845
82846
82847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
82848   int jresult ;
82849   int result;
82850
82851   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
82852   jresult = (int)result;
82853   return jresult;
82854 }
82855
82856
82857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
82858   int jresult ;
82859   int result;
82860
82861   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
82862   jresult = (int)result;
82863   return jresult;
82864 }
82865
82866
82867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
82868   void * jresult ;
82869   Dali::Toolkit::TextLabel::Property *result = 0 ;
82870
82871   {
82872     try {
82873       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
82874     } catch (std::out_of_range& e) {
82875       {
82876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82877       };
82878     } catch (std::exception& e) {
82879       {
82880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82881       };
82882     } catch (Dali::DaliException e) {
82883       {
82884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82885       };
82886     } catch (...) {
82887       {
82888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82889       };
82890     }
82891   }
82892
82893   jresult = (void *)result;
82894   return jresult;
82895 }
82896
82897
82898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
82899   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
82900
82901   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
82902   {
82903     try {
82904       delete arg1;
82905     } catch (std::out_of_range& e) {
82906       {
82907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82908       };
82909     } catch (std::exception& e) {
82910       {
82911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82912       };
82913     } catch (Dali::DaliException e) {
82914       {
82915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82916       };
82917     } catch (...) {
82918       {
82919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82920       };
82921     }
82922   }
82923
82924 }
82925
82926
82927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
82928   void * jresult ;
82929   Dali::Toolkit::TextLabel result;
82930
82931   {
82932     try {
82933       result = Dali::Toolkit::TextLabel::New();
82934     } catch (std::out_of_range& e) {
82935       {
82936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82937       };
82938     } catch (std::exception& e) {
82939       {
82940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82941       };
82942     } catch (Dali::DaliException e) {
82943       {
82944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82945       };
82946     } catch (...) {
82947       {
82948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82949       };
82950     }
82951   }
82952
82953   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
82954   return jresult;
82955 }
82956
82957
82958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
82959   void * jresult ;
82960   std::string *arg1 = 0 ;
82961   Dali::Toolkit::TextLabel result;
82962
82963   if (!jarg1) {
82964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82965     return 0;
82966   }
82967   std::string arg1_str(jarg1);
82968   arg1 = &arg1_str;
82969   {
82970     try {
82971       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
82972     } catch (std::out_of_range& e) {
82973       {
82974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82975       };
82976     } catch (std::exception& e) {
82977       {
82978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82979       };
82980     } catch (Dali::DaliException e) {
82981       {
82982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82983       };
82984     } catch (...) {
82985       {
82986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82987       };
82988     }
82989   }
82990
82991   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
82992
82993   //argout typemap for const std::string&
82994
82995   return jresult;
82996 }
82997
82998
82999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
83000   void * jresult ;
83001   Dali::Toolkit::TextLabel *result = 0 ;
83002
83003   {
83004     try {
83005       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
83006     } catch (std::out_of_range& e) {
83007       {
83008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83009       };
83010     } catch (std::exception& e) {
83011       {
83012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83013       };
83014     } catch (Dali::DaliException e) {
83015       {
83016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83017       };
83018     } catch (...) {
83019       {
83020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83021       };
83022     }
83023   }
83024
83025   jresult = (void *)result;
83026   return jresult;
83027 }
83028
83029
83030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
83031   void * jresult ;
83032   Dali::Toolkit::TextLabel *arg1 = 0 ;
83033   Dali::Toolkit::TextLabel *result = 0 ;
83034
83035   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83036   if (!arg1) {
83037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83038     return 0;
83039   }
83040   {
83041     try {
83042       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
83043     } catch (std::out_of_range& e) {
83044       {
83045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83046       };
83047     } catch (std::exception& e) {
83048       {
83049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83050       };
83051     } catch (Dali::DaliException e) {
83052       {
83053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83054       };
83055     } catch (...) {
83056       {
83057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83058       };
83059     }
83060   }
83061
83062   jresult = (void *)result;
83063   return jresult;
83064 }
83065
83066
83067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
83068   void * jresult ;
83069   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83070   Dali::Toolkit::TextLabel *arg2 = 0 ;
83071   Dali::Toolkit::TextLabel *result = 0 ;
83072
83073   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83074   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
83075   if (!arg2) {
83076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83077     return 0;
83078   }
83079   {
83080     try {
83081       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
83082     } catch (std::out_of_range& e) {
83083       {
83084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83085       };
83086     } catch (std::exception& e) {
83087       {
83088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83089       };
83090     } catch (Dali::DaliException e) {
83091       {
83092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83093       };
83094     } catch (...) {
83095       {
83096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83097       };
83098     }
83099   }
83100
83101   jresult = (void *)result;
83102   return jresult;
83103 }
83104
83105
83106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
83107   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83108
83109   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83110   {
83111     try {
83112       delete arg1;
83113     } catch (std::out_of_range& e) {
83114       {
83115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83116       };
83117     } catch (std::exception& e) {
83118       {
83119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83120       };
83121     } catch (Dali::DaliException e) {
83122       {
83123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83124       };
83125     } catch (...) {
83126       {
83127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83128       };
83129     }
83130   }
83131
83132 }
83133
83134
83135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
83136   void * jresult ;
83137   Dali::BaseHandle arg1 ;
83138   Dali::BaseHandle *argp1 ;
83139   Dali::Toolkit::TextLabel result;
83140
83141   argp1 = (Dali::BaseHandle *)jarg1;
83142   if (!argp1) {
83143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83144     return 0;
83145   }
83146   arg1 = *argp1;
83147   {
83148     try {
83149       result = Dali::Toolkit::TextLabel::DownCast(arg1);
83150     } catch (std::out_of_range& e) {
83151       {
83152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83153       };
83154     } catch (std::exception& e) {
83155       {
83156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83157       };
83158     } catch (Dali::DaliException e) {
83159       {
83160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83161       };
83162     } catch (...) {
83163       {
83164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83165       };
83166     }
83167   }
83168
83169   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83170   return jresult;
83171 }
83172
83173
83174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
83175   void * jresult ;
83176   Dali::Toolkit::AccessibilityManager *result = 0 ;
83177
83178   {
83179     try {
83180       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
83181     } catch (std::out_of_range& e) {
83182       {
83183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83184       };
83185     } catch (std::exception& e) {
83186       {
83187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83188       };
83189     } catch (Dali::DaliException e) {
83190       {
83191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83192       };
83193     } catch (...) {
83194       {
83195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83196       };
83197     }
83198   }
83199
83200   jresult = (void *)result;
83201   return jresult;
83202 }
83203
83204
83205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
83206   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83207
83208   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83209   {
83210     try {
83211       delete arg1;
83212     } catch (std::out_of_range& e) {
83213       {
83214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83215       };
83216     } catch (std::exception& e) {
83217       {
83218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83219       };
83220     } catch (Dali::DaliException e) {
83221       {
83222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83223       };
83224     } catch (...) {
83225       {
83226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83227       };
83228     }
83229   }
83230
83231 }
83232
83233
83234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
83235   void * jresult ;
83236   Dali::Toolkit::AccessibilityManager result;
83237
83238   {
83239     try {
83240       result = Dali::Toolkit::AccessibilityManager::Get();
83241     } catch (std::out_of_range& e) {
83242       {
83243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83244       };
83245     } catch (std::exception& e) {
83246       {
83247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83248       };
83249     } catch (Dali::DaliException e) {
83250       {
83251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83252       };
83253     } catch (...) {
83254       {
83255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83256       };
83257     }
83258   }
83259
83260   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
83261   return jresult;
83262 }
83263
83264
83265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
83266   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83267   Dali::Actor arg2 ;
83268   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83269   std::string *arg4 = 0 ;
83270   Dali::Actor *argp2 ;
83271
83272   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83273   argp2 = (Dali::Actor *)jarg2;
83274   if (!argp2) {
83275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83276     return ;
83277   }
83278   arg2 = *argp2;
83279   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83280   if (!jarg4) {
83281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83282     return ;
83283   }
83284   std::string arg4_str(jarg4);
83285   arg4 = &arg4_str;
83286   {
83287     try {
83288       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
83289     } catch (std::out_of_range& e) {
83290       {
83291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83292       };
83293     } catch (std::exception& e) {
83294       {
83295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83296       };
83297     } catch (Dali::DaliException e) {
83298       {
83299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83300       };
83301     } catch (...) {
83302       {
83303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83304       };
83305     }
83306   }
83307
83308
83309   //argout typemap for const std::string&
83310
83311 }
83312
83313
83314 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
83315   char * jresult ;
83316   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83317   Dali::Actor arg2 ;
83318   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83319   Dali::Actor *argp2 ;
83320   std::string result;
83321
83322   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83323   argp2 = (Dali::Actor *)jarg2;
83324   if (!argp2) {
83325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83326     return 0;
83327   }
83328   arg2 = *argp2;
83329   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83330   {
83331     try {
83332       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
83333     } catch (std::out_of_range& e) {
83334       {
83335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83336       };
83337     } catch (std::exception& e) {
83338       {
83339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83340       };
83341     } catch (Dali::DaliException e) {
83342       {
83343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83344       };
83345     } catch (...) {
83346       {
83347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83348       };
83349     }
83350   }
83351
83352   jresult = SWIG_csharp_string_callback((&result)->c_str());
83353   return jresult;
83354 }
83355
83356
83357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
83358   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83359   Dali::Actor arg2 ;
83360   unsigned int arg3 ;
83361   Dali::Actor *argp2 ;
83362
83363   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83364   argp2 = (Dali::Actor *)jarg2;
83365   if (!argp2) {
83366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83367     return ;
83368   }
83369   arg2 = *argp2;
83370   arg3 = (unsigned int)jarg3;
83371   {
83372     try {
83373       (arg1)->SetFocusOrder(arg2,arg3);
83374     } catch (std::out_of_range& e) {
83375       {
83376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83377       };
83378     } catch (std::exception& e) {
83379       {
83380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83381       };
83382     } catch (Dali::DaliException e) {
83383       {
83384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83385       };
83386     } catch (...) {
83387       {
83388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83389       };
83390     }
83391   }
83392
83393 }
83394
83395
83396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
83397   unsigned int jresult ;
83398   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83399   Dali::Actor arg2 ;
83400   Dali::Actor *argp2 ;
83401   unsigned int result;
83402
83403   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83404   argp2 = (Dali::Actor *)jarg2;
83405   if (!argp2) {
83406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83407     return 0;
83408   }
83409   arg2 = *argp2;
83410   {
83411     try {
83412       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
83413     } catch (std::out_of_range& e) {
83414       {
83415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83416       };
83417     } catch (std::exception& e) {
83418       {
83419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83420       };
83421     } catch (Dali::DaliException e) {
83422       {
83423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83424       };
83425     } catch (...) {
83426       {
83427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83428       };
83429     }
83430   }
83431
83432   jresult = result;
83433   return jresult;
83434 }
83435
83436
83437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
83438   unsigned int jresult ;
83439   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83440   unsigned int result;
83441
83442   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83443   {
83444     try {
83445       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
83446     } catch (std::out_of_range& e) {
83447       {
83448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83449       };
83450     } catch (std::exception& e) {
83451       {
83452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83453       };
83454     } catch (Dali::DaliException e) {
83455       {
83456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83457       };
83458     } catch (...) {
83459       {
83460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83461       };
83462     }
83463   }
83464
83465   jresult = result;
83466   return jresult;
83467 }
83468
83469
83470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
83471   void * jresult ;
83472   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83473   unsigned int arg2 ;
83474   Dali::Actor result;
83475
83476   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83477   arg2 = (unsigned int)jarg2;
83478   {
83479     try {
83480       result = (arg1)->GetActorByFocusOrder(arg2);
83481     } catch (std::out_of_range& e) {
83482       {
83483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83484       };
83485     } catch (std::exception& e) {
83486       {
83487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83488       };
83489     } catch (Dali::DaliException e) {
83490       {
83491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83492       };
83493     } catch (...) {
83494       {
83495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83496       };
83497     }
83498   }
83499
83500   jresult = new Dali::Actor((const Dali::Actor &)result);
83501   return jresult;
83502 }
83503
83504
83505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
83506   unsigned int jresult ;
83507   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83508   Dali::Actor arg2 ;
83509   Dali::Actor *argp2 ;
83510   bool result;
83511
83512   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83513   argp2 = (Dali::Actor *)jarg2;
83514   if (!argp2) {
83515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83516     return 0;
83517   }
83518   arg2 = *argp2;
83519   {
83520     try {
83521       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
83522     } catch (std::out_of_range& e) {
83523       {
83524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83525       };
83526     } catch (std::exception& e) {
83527       {
83528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83529       };
83530     } catch (Dali::DaliException e) {
83531       {
83532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83533       };
83534     } catch (...) {
83535       {
83536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83537       };
83538     }
83539   }
83540
83541   jresult = result;
83542   return jresult;
83543 }
83544
83545
83546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
83547   void * jresult ;
83548   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83549   Dali::Actor result;
83550
83551   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83552   {
83553     try {
83554       result = (arg1)->GetCurrentFocusActor();
83555     } catch (std::out_of_range& e) {
83556       {
83557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83558       };
83559     } catch (std::exception& e) {
83560       {
83561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83562       };
83563     } catch (Dali::DaliException e) {
83564       {
83565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83566       };
83567     } catch (...) {
83568       {
83569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83570       };
83571     }
83572   }
83573
83574   jresult = new Dali::Actor((const Dali::Actor &)result);
83575   return jresult;
83576 }
83577
83578
83579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
83580   void * jresult ;
83581   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83582   Dali::Actor result;
83583
83584   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83585   {
83586     try {
83587       result = (arg1)->GetCurrentFocusGroup();
83588     } catch (std::out_of_range& e) {
83589       {
83590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83591       };
83592     } catch (std::exception& e) {
83593       {
83594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83595       };
83596     } catch (Dali::DaliException e) {
83597       {
83598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83599       };
83600     } catch (...) {
83601       {
83602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83603       };
83604     }
83605   }
83606
83607   jresult = new Dali::Actor((const Dali::Actor &)result);
83608   return jresult;
83609 }
83610
83611
83612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
83613   unsigned int jresult ;
83614   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83615   unsigned int result;
83616
83617   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83618   {
83619     try {
83620       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
83621     } catch (std::out_of_range& e) {
83622       {
83623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83624       };
83625     } catch (std::exception& e) {
83626       {
83627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83628       };
83629     } catch (Dali::DaliException e) {
83630       {
83631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83632       };
83633     } catch (...) {
83634       {
83635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83636       };
83637     }
83638   }
83639
83640   jresult = result;
83641   return jresult;
83642 }
83643
83644
83645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
83646   unsigned int jresult ;
83647   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83648   bool result;
83649
83650   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83651   {
83652     try {
83653       result = (bool)(arg1)->MoveFocusForward();
83654     } catch (std::out_of_range& e) {
83655       {
83656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83657       };
83658     } catch (std::exception& e) {
83659       {
83660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83661       };
83662     } catch (Dali::DaliException e) {
83663       {
83664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83665       };
83666     } catch (...) {
83667       {
83668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83669       };
83670     }
83671   }
83672
83673   jresult = result;
83674   return jresult;
83675 }
83676
83677
83678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
83679   unsigned int jresult ;
83680   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83681   bool result;
83682
83683   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83684   {
83685     try {
83686       result = (bool)(arg1)->MoveFocusBackward();
83687     } catch (std::out_of_range& e) {
83688       {
83689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83690       };
83691     } catch (std::exception& e) {
83692       {
83693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83694       };
83695     } catch (Dali::DaliException e) {
83696       {
83697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83698       };
83699     } catch (...) {
83700       {
83701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83702       };
83703     }
83704   }
83705
83706   jresult = result;
83707   return jresult;
83708 }
83709
83710
83711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
83712   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83713
83714   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83715   {
83716     try {
83717       (arg1)->ClearFocus();
83718     } catch (std::out_of_range& e) {
83719       {
83720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83721       };
83722     } catch (std::exception& e) {
83723       {
83724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83725       };
83726     } catch (Dali::DaliException e) {
83727       {
83728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83729       };
83730     } catch (...) {
83731       {
83732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83733       };
83734     }
83735   }
83736
83737 }
83738
83739
83740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
83741   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83742
83743   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83744   {
83745     try {
83746       (arg1)->Reset();
83747     } catch (std::out_of_range& e) {
83748       {
83749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83750       };
83751     } catch (std::exception& e) {
83752       {
83753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83754       };
83755     } catch (Dali::DaliException e) {
83756       {
83757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83758       };
83759     } catch (...) {
83760       {
83761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83762       };
83763     }
83764   }
83765
83766 }
83767
83768
83769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
83770   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83771   Dali::Actor arg2 ;
83772   bool arg3 ;
83773   Dali::Actor *argp2 ;
83774
83775   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83776   argp2 = (Dali::Actor *)jarg2;
83777   if (!argp2) {
83778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83779     return ;
83780   }
83781   arg2 = *argp2;
83782   arg3 = jarg3 ? true : false;
83783   {
83784     try {
83785       (arg1)->SetFocusGroup(arg2,arg3);
83786     } catch (std::out_of_range& e) {
83787       {
83788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83789       };
83790     } catch (std::exception& e) {
83791       {
83792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83793       };
83794     } catch (Dali::DaliException e) {
83795       {
83796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83797       };
83798     } catch (...) {
83799       {
83800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83801       };
83802     }
83803   }
83804
83805 }
83806
83807
83808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
83809   unsigned int jresult ;
83810   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83811   Dali::Actor arg2 ;
83812   Dali::Actor *argp2 ;
83813   bool result;
83814
83815   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83816   argp2 = (Dali::Actor *)jarg2;
83817   if (!argp2) {
83818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83819     return 0;
83820   }
83821   arg2 = *argp2;
83822   {
83823     try {
83824       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
83825     } catch (std::out_of_range& e) {
83826       {
83827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83828       };
83829     } catch (std::exception& e) {
83830       {
83831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83832       };
83833     } catch (Dali::DaliException e) {
83834       {
83835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83836       };
83837     } catch (...) {
83838       {
83839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83840       };
83841     }
83842   }
83843
83844   jresult = result;
83845   return jresult;
83846 }
83847
83848
83849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
83850   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83851   bool arg2 ;
83852
83853   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83854   arg2 = jarg2 ? true : false;
83855   {
83856     try {
83857       (arg1)->SetGroupMode(arg2);
83858     } catch (std::out_of_range& e) {
83859       {
83860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83861       };
83862     } catch (std::exception& e) {
83863       {
83864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83865       };
83866     } catch (Dali::DaliException e) {
83867       {
83868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83869       };
83870     } catch (...) {
83871       {
83872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83873       };
83874     }
83875   }
83876
83877 }
83878
83879
83880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
83881   unsigned int jresult ;
83882   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83883   bool result;
83884
83885   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83886   {
83887     try {
83888       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
83889     } catch (std::out_of_range& e) {
83890       {
83891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83892       };
83893     } catch (std::exception& e) {
83894       {
83895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83896       };
83897     } catch (Dali::DaliException e) {
83898       {
83899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83900       };
83901     } catch (...) {
83902       {
83903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83904       };
83905     }
83906   }
83907
83908   jresult = result;
83909   return jresult;
83910 }
83911
83912
83913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
83914   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83915   bool arg2 ;
83916
83917   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83918   arg2 = jarg2 ? true : false;
83919   {
83920     try {
83921       (arg1)->SetWrapMode(arg2);
83922     } catch (std::out_of_range& e) {
83923       {
83924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83925       };
83926     } catch (std::exception& e) {
83927       {
83928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83929       };
83930     } catch (Dali::DaliException e) {
83931       {
83932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83933       };
83934     } catch (...) {
83935       {
83936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83937       };
83938     }
83939   }
83940
83941 }
83942
83943
83944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
83945   unsigned int jresult ;
83946   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83947   bool result;
83948
83949   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83950   {
83951     try {
83952       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
83953     } catch (std::out_of_range& e) {
83954       {
83955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83956       };
83957     } catch (std::exception& e) {
83958       {
83959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83960       };
83961     } catch (Dali::DaliException e) {
83962       {
83963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83964       };
83965     } catch (...) {
83966       {
83967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83968       };
83969     }
83970   }
83971
83972   jresult = result;
83973   return jresult;
83974 }
83975
83976
83977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
83978   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83979   Dali::Actor arg2 ;
83980   Dali::Actor *argp2 ;
83981
83982   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83983   argp2 = (Dali::Actor *)jarg2;
83984   if (!argp2) {
83985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83986     return ;
83987   }
83988   arg2 = *argp2;
83989   {
83990     try {
83991       (arg1)->SetFocusIndicatorActor(arg2);
83992     } catch (std::out_of_range& e) {
83993       {
83994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83995       };
83996     } catch (std::exception& e) {
83997       {
83998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83999       };
84000     } catch (Dali::DaliException e) {
84001       {
84002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84003       };
84004     } catch (...) {
84005       {
84006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84007       };
84008     }
84009   }
84010
84011 }
84012
84013
84014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
84015   void * jresult ;
84016   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84017   Dali::Actor result;
84018
84019   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84020   {
84021     try {
84022       result = (arg1)->GetFocusIndicatorActor();
84023     } catch (std::out_of_range& e) {
84024       {
84025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84026       };
84027     } catch (std::exception& e) {
84028       {
84029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84030       };
84031     } catch (Dali::DaliException e) {
84032       {
84033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84034       };
84035     } catch (...) {
84036       {
84037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84038       };
84039     }
84040   }
84041
84042   jresult = new Dali::Actor((const Dali::Actor &)result);
84043   return jresult;
84044 }
84045
84046
84047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
84048   void * jresult ;
84049   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84050   Dali::Actor arg2 ;
84051   Dali::Actor *argp2 ;
84052   Dali::Actor result;
84053
84054   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84055   argp2 = (Dali::Actor *)jarg2;
84056   if (!argp2) {
84057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84058     return 0;
84059   }
84060   arg2 = *argp2;
84061   {
84062     try {
84063       result = (arg1)->GetFocusGroup(arg2);
84064     } catch (std::out_of_range& e) {
84065       {
84066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84067       };
84068     } catch (std::exception& e) {
84069       {
84070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84071       };
84072     } catch (Dali::DaliException e) {
84073       {
84074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84075       };
84076     } catch (...) {
84077       {
84078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84079       };
84080     }
84081   }
84082
84083   jresult = new Dali::Actor((const Dali::Actor &)result);
84084   return jresult;
84085 }
84086
84087
84088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
84089   void * jresult ;
84090   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84091   Dali::Vector2 result;
84092
84093   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84094   {
84095     try {
84096       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
84097     } catch (std::out_of_range& e) {
84098       {
84099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84100       };
84101     } catch (std::exception& e) {
84102       {
84103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84104       };
84105     } catch (Dali::DaliException e) {
84106       {
84107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84108       };
84109     } catch (...) {
84110       {
84111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84112       };
84113     }
84114   }
84115
84116   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
84117   return jresult;
84118 }
84119
84120
84121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
84122   void * jresult ;
84123   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84124   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
84125
84126   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84127   {
84128     try {
84129       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
84130     } catch (std::out_of_range& e) {
84131       {
84132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84133       };
84134     } catch (std::exception& e) {
84135       {
84136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84137       };
84138     } catch (Dali::DaliException e) {
84139       {
84140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84141       };
84142     } catch (...) {
84143       {
84144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84145       };
84146     }
84147   }
84148
84149   jresult = (void *)result;
84150   return jresult;
84151 }
84152
84153
84154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
84155   void * jresult ;
84156   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84157   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
84158
84159   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84160   {
84161     try {
84162       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
84163     } catch (std::out_of_range& e) {
84164       {
84165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84166       };
84167     } catch (std::exception& e) {
84168       {
84169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84170       };
84171     } catch (Dali::DaliException e) {
84172       {
84173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84174       };
84175     } catch (...) {
84176       {
84177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84178       };
84179     }
84180   }
84181
84182   jresult = (void *)result;
84183   return jresult;
84184 }
84185
84186
84187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
84188   void * jresult ;
84189   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84190   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
84191
84192   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84193   {
84194     try {
84195       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
84196     } catch (std::out_of_range& e) {
84197       {
84198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84199       };
84200     } catch (std::exception& e) {
84201       {
84202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84203       };
84204     } catch (Dali::DaliException e) {
84205       {
84206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84207       };
84208     } catch (...) {
84209       {
84210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84211       };
84212     }
84213   }
84214
84215   jresult = (void *)result;
84216   return jresult;
84217 }
84218
84219
84220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
84221   void * jresult ;
84222   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84223   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84224
84225   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84226   {
84227     try {
84228       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
84229     } catch (std::out_of_range& e) {
84230       {
84231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84232       };
84233     } catch (std::exception& e) {
84234       {
84235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84236       };
84237     } catch (Dali::DaliException e) {
84238       {
84239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84240       };
84241     } catch (...) {
84242       {
84243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84244       };
84245     }
84246   }
84247
84248   jresult = (void *)result;
84249   return jresult;
84250 }
84251
84252
84253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
84254   void * jresult ;
84255   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84256   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84257
84258   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84259   {
84260     try {
84261       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
84262     } catch (std::out_of_range& e) {
84263       {
84264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84265       };
84266     } catch (std::exception& e) {
84267       {
84268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84269       };
84270     } catch (Dali::DaliException e) {
84271       {
84272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84273       };
84274     } catch (...) {
84275       {
84276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84277       };
84278     }
84279   }
84280
84281   jresult = (void *)result;
84282   return jresult;
84283 }
84284
84285
84286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
84287   void * jresult ;
84288   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84289   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84290
84291   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84292   {
84293     try {
84294       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
84295     } catch (std::out_of_range& e) {
84296       {
84297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84298       };
84299     } catch (std::exception& e) {
84300       {
84301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84302       };
84303     } catch (Dali::DaliException e) {
84304       {
84305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84306       };
84307     } catch (...) {
84308       {
84309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84310       };
84311     }
84312   }
84313
84314   jresult = (void *)result;
84315   return jresult;
84316 }
84317
84318
84319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
84320   void * jresult ;
84321   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84322   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84323
84324   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84325   {
84326     try {
84327       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
84328     } catch (std::out_of_range& e) {
84329       {
84330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84331       };
84332     } catch (std::exception& e) {
84333       {
84334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84335       };
84336     } catch (Dali::DaliException e) {
84337       {
84338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84339       };
84340     } catch (...) {
84341       {
84342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84343       };
84344     }
84345   }
84346
84347   jresult = (void *)result;
84348   return jresult;
84349 }
84350
84351
84352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
84353   void * jresult ;
84354   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84355   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84356
84357   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84358   {
84359     try {
84360       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
84361     } catch (std::out_of_range& e) {
84362       {
84363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84364       };
84365     } catch (std::exception& e) {
84366       {
84367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84368       };
84369     } catch (Dali::DaliException e) {
84370       {
84371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84372       };
84373     } catch (...) {
84374       {
84375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84376       };
84377     }
84378   }
84379
84380   jresult = (void *)result;
84381   return jresult;
84382 }
84383
84384
84385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
84386   void * jresult ;
84387   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84388   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84389
84390   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84391   {
84392     try {
84393       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
84394     } catch (std::out_of_range& e) {
84395       {
84396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84397       };
84398     } catch (std::exception& e) {
84399       {
84400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84401       };
84402     } catch (Dali::DaliException e) {
84403       {
84404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84405       };
84406     } catch (...) {
84407       {
84408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84409       };
84410     }
84411   }
84412
84413   jresult = (void *)result;
84414   return jresult;
84415 }
84416
84417
84418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
84419   void * jresult ;
84420   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84421   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84422
84423   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84424   {
84425     try {
84426       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
84427     } catch (std::out_of_range& e) {
84428       {
84429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84430       };
84431     } catch (std::exception& e) {
84432       {
84433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84434       };
84435     } catch (Dali::DaliException e) {
84436       {
84437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84438       };
84439     } catch (...) {
84440       {
84441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84442       };
84443     }
84444   }
84445
84446   jresult = (void *)result;
84447   return jresult;
84448 }
84449
84450
84451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
84452   void * jresult ;
84453   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84454   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84455
84456   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84457   {
84458     try {
84459       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
84460     } catch (std::out_of_range& e) {
84461       {
84462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84463       };
84464     } catch (std::exception& e) {
84465       {
84466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84467       };
84468     } catch (Dali::DaliException e) {
84469       {
84470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84471       };
84472     } catch (...) {
84473       {
84474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84475       };
84476     }
84477   }
84478
84479   jresult = (void *)result;
84480   return jresult;
84481 }
84482
84483
84484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
84485   void * jresult ;
84486   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84487   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84488
84489   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84490   {
84491     try {
84492       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
84493     } catch (std::out_of_range& e) {
84494       {
84495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84496       };
84497     } catch (std::exception& e) {
84498       {
84499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84500       };
84501     } catch (Dali::DaliException e) {
84502       {
84503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84504       };
84505     } catch (...) {
84506       {
84507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84508       };
84509     }
84510   }
84511
84512   jresult = (void *)result;
84513   return jresult;
84514 }
84515
84516
84517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
84518   void * jresult ;
84519   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84520   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84521
84522   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84523   {
84524     try {
84525       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
84526     } catch (std::out_of_range& e) {
84527       {
84528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84529       };
84530     } catch (std::exception& e) {
84531       {
84532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84533       };
84534     } catch (Dali::DaliException e) {
84535       {
84536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84537       };
84538     } catch (...) {
84539       {
84540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84541       };
84542     }
84543   }
84544
84545   jresult = (void *)result;
84546   return jresult;
84547 }
84548
84549
84550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
84551   void * jresult ;
84552   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84553   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84554
84555   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84556   {
84557     try {
84558       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
84559     } catch (std::out_of_range& e) {
84560       {
84561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84562       };
84563     } catch (std::exception& e) {
84564       {
84565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84566       };
84567     } catch (Dali::DaliException e) {
84568       {
84569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84570       };
84571     } catch (...) {
84572       {
84573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84574       };
84575     }
84576   }
84577
84578   jresult = (void *)result;
84579   return jresult;
84580 }
84581
84582
84583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
84584   void * jresult ;
84585   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84586   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84587
84588   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84589   {
84590     try {
84591       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
84592     } catch (std::out_of_range& e) {
84593       {
84594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84595       };
84596     } catch (std::exception& e) {
84597       {
84598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84599       };
84600     } catch (Dali::DaliException e) {
84601       {
84602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84603       };
84604     } catch (...) {
84605       {
84606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84607       };
84608     }
84609   }
84610
84611   jresult = (void *)result;
84612   return jresult;
84613 }
84614
84615
84616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
84617   void * jresult ;
84618   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84619   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84620
84621   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84622   {
84623     try {
84624       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
84625     } catch (std::out_of_range& e) {
84626       {
84627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84628       };
84629     } catch (std::exception& e) {
84630       {
84631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84632       };
84633     } catch (Dali::DaliException e) {
84634       {
84635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84636       };
84637     } catch (...) {
84638       {
84639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84640       };
84641     }
84642   }
84643
84644   jresult = (void *)result;
84645   return jresult;
84646 }
84647
84648
84649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
84650   void * jresult ;
84651   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84652   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84653
84654   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84655   {
84656     try {
84657       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
84658     } catch (std::out_of_range& e) {
84659       {
84660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84661       };
84662     } catch (std::exception& e) {
84663       {
84664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84665       };
84666     } catch (Dali::DaliException e) {
84667       {
84668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84669       };
84670     } catch (...) {
84671       {
84672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84673       };
84674     }
84675   }
84676
84677   jresult = (void *)result;
84678   return jresult;
84679 }
84680
84681
84682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
84683   void * jresult ;
84684   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84685   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84686
84687   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84688   {
84689     try {
84690       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
84691     } catch (std::out_of_range& e) {
84692       {
84693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84694       };
84695     } catch (std::exception& e) {
84696       {
84697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84698       };
84699     } catch (Dali::DaliException e) {
84700       {
84701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84702       };
84703     } catch (...) {
84704       {
84705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84706       };
84707     }
84708   }
84709
84710   jresult = (void *)result;
84711   return jresult;
84712 }
84713
84714
84715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
84716   void * jresult ;
84717   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84718   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84719
84720   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84721   {
84722     try {
84723       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
84724     } catch (std::out_of_range& e) {
84725       {
84726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84727       };
84728     } catch (std::exception& e) {
84729       {
84730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84731       };
84732     } catch (Dali::DaliException e) {
84733       {
84734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84735       };
84736     } catch (...) {
84737       {
84738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84739       };
84740     }
84741   }
84742
84743   jresult = (void *)result;
84744   return jresult;
84745 }
84746
84747
84748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
84749   void * jresult ;
84750   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84751   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84752
84753   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84754   {
84755     try {
84756       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
84757     } catch (std::out_of_range& e) {
84758       {
84759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84760       };
84761     } catch (std::exception& e) {
84762       {
84763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84764       };
84765     } catch (Dali::DaliException e) {
84766       {
84767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84768       };
84769     } catch (...) {
84770       {
84771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84772       };
84773     }
84774   }
84775
84776   jresult = (void *)result;
84777   return jresult;
84778 }
84779
84780
84781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
84782   void * jresult ;
84783   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84784   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84785
84786   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84787   {
84788     try {
84789       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
84790     } catch (std::out_of_range& e) {
84791       {
84792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84793       };
84794     } catch (std::exception& e) {
84795       {
84796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84797       };
84798     } catch (Dali::DaliException e) {
84799       {
84800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84801       };
84802     } catch (...) {
84803       {
84804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84805       };
84806     }
84807   }
84808
84809   jresult = (void *)result;
84810   return jresult;
84811 }
84812
84813
84814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
84815   void * jresult ;
84816   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84817   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84818
84819   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84820   {
84821     try {
84822       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
84823     } catch (std::out_of_range& e) {
84824       {
84825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84826       };
84827     } catch (std::exception& e) {
84828       {
84829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84830       };
84831     } catch (Dali::DaliException e) {
84832       {
84833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84834       };
84835     } catch (...) {
84836       {
84837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84838       };
84839     }
84840   }
84841
84842   jresult = (void *)result;
84843   return jresult;
84844 }
84845
84846
84847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
84848   void * jresult ;
84849   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84850   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84851
84852   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84853   {
84854     try {
84855       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
84856     } catch (std::out_of_range& e) {
84857       {
84858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84859       };
84860     } catch (std::exception& e) {
84861       {
84862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84863       };
84864     } catch (Dali::DaliException e) {
84865       {
84866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84867       };
84868     } catch (...) {
84869       {
84870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84871       };
84872     }
84873   }
84874
84875   jresult = (void *)result;
84876   return jresult;
84877 }
84878
84879
84880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
84881   void * jresult ;
84882   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84883   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84884
84885   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84886   {
84887     try {
84888       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
84889     } catch (std::out_of_range& e) {
84890       {
84891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84892       };
84893     } catch (std::exception& e) {
84894       {
84895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84896       };
84897     } catch (Dali::DaliException e) {
84898       {
84899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84900       };
84901     } catch (...) {
84902       {
84903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84904       };
84905     }
84906   }
84907
84908   jresult = (void *)result;
84909   return jresult;
84910 }
84911
84912
84913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
84914   void * jresult ;
84915   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84916   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84917
84918   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84919   {
84920     try {
84921       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
84922     } catch (std::out_of_range& e) {
84923       {
84924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84925       };
84926     } catch (std::exception& e) {
84927       {
84928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84929       };
84930     } catch (Dali::DaliException e) {
84931       {
84932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84933       };
84934     } catch (...) {
84935       {
84936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84937       };
84938     }
84939   }
84940
84941   jresult = (void *)result;
84942   return jresult;
84943 }
84944
84945
84946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
84947   void * jresult ;
84948   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84949   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84950
84951   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84952   {
84953     try {
84954       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
84955     } catch (std::out_of_range& e) {
84956       {
84957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84958       };
84959     } catch (std::exception& e) {
84960       {
84961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84962       };
84963     } catch (Dali::DaliException e) {
84964       {
84965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84966       };
84967     } catch (...) {
84968       {
84969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84970       };
84971     }
84972   }
84973
84974   jresult = (void *)result;
84975   return jresult;
84976 }
84977
84978
84979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
84980   void * jresult ;
84981   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84982   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84983
84984   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84985   {
84986     try {
84987       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
84988     } catch (std::out_of_range& e) {
84989       {
84990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84991       };
84992     } catch (std::exception& e) {
84993       {
84994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84995       };
84996     } catch (Dali::DaliException e) {
84997       {
84998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84999       };
85000     } catch (...) {
85001       {
85002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85003       };
85004     }
85005   }
85006
85007   jresult = (void *)result;
85008   return jresult;
85009 }
85010
85011
85012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
85013   void * jresult ;
85014   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85015   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85016
85017   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85018   {
85019     try {
85020       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
85021     } catch (std::out_of_range& e) {
85022       {
85023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85024       };
85025     } catch (std::exception& e) {
85026       {
85027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85028       };
85029     } catch (Dali::DaliException e) {
85030       {
85031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85032       };
85033     } catch (...) {
85034       {
85035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85036       };
85037     }
85038   }
85039
85040   jresult = (void *)result;
85041   return jresult;
85042 }
85043
85044
85045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
85046   void * jresult ;
85047   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85048   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85049
85050   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85051   {
85052     try {
85053       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
85054     } catch (std::out_of_range& e) {
85055       {
85056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85057       };
85058     } catch (std::exception& e) {
85059       {
85060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85061       };
85062     } catch (Dali::DaliException e) {
85063       {
85064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85065       };
85066     } catch (...) {
85067       {
85068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85069       };
85070     }
85071   }
85072
85073   jresult = (void *)result;
85074   return jresult;
85075 }
85076
85077
85078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
85079   void * jresult ;
85080   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85081   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
85082
85083   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85084   {
85085     try {
85086       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
85087     } catch (std::out_of_range& e) {
85088       {
85089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85090       };
85091     } catch (std::exception& e) {
85092       {
85093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85094       };
85095     } catch (Dali::DaliException e) {
85096       {
85097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85098       };
85099     } catch (...) {
85100       {
85101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85102       };
85103     }
85104   }
85105
85106   jresult = (void *)result;
85107   return jresult;
85108 }
85109
85110
85111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
85112   void * jresult ;
85113   Dali::Toolkit::StyleManager *result = 0 ;
85114
85115   {
85116     try {
85117       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
85118     } catch (std::out_of_range& e) {
85119       {
85120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85121       };
85122     } catch (std::exception& e) {
85123       {
85124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85125       };
85126     } catch (Dali::DaliException e) {
85127       {
85128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85129       };
85130     } catch (...) {
85131       {
85132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85133       };
85134     }
85135   }
85136
85137   jresult = (void *)result;
85138   return jresult;
85139 }
85140
85141
85142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
85143   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85144
85145   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85146   {
85147     try {
85148       delete arg1;
85149     } catch (std::out_of_range& e) {
85150       {
85151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85152       };
85153     } catch (std::exception& e) {
85154       {
85155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85156       };
85157     } catch (Dali::DaliException e) {
85158       {
85159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85160       };
85161     } catch (...) {
85162       {
85163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85164       };
85165     }
85166   }
85167
85168 }
85169
85170
85171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
85172   void * jresult ;
85173   Dali::Toolkit::StyleManager result;
85174
85175   {
85176     try {
85177       result = Dali::Toolkit::StyleManager::Get();
85178     } catch (std::out_of_range& e) {
85179       {
85180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85181       };
85182     } catch (std::exception& e) {
85183       {
85184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85185       };
85186     } catch (Dali::DaliException e) {
85187       {
85188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85189       };
85190     } catch (...) {
85191       {
85192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85193       };
85194     }
85195   }
85196
85197   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
85198   return jresult;
85199 }
85200
85201
85202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
85203   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85204   std::string *arg2 = 0 ;
85205
85206   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85207   if (!jarg2) {
85208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85209     return ;
85210   }
85211   std::string arg2_str(jarg2);
85212   arg2 = &arg2_str;
85213   {
85214     try {
85215       (arg1)->ApplyTheme((std::string const &)*arg2);
85216     } catch (std::out_of_range& e) {
85217       {
85218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85219       };
85220     } catch (std::exception& e) {
85221       {
85222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85223       };
85224     } catch (Dali::DaliException e) {
85225       {
85226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85227       };
85228     } catch (...) {
85229       {
85230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85231       };
85232     }
85233   }
85234
85235
85236   //argout typemap for const std::string&
85237
85238 }
85239
85240
85241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
85242   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85243
85244   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85245   {
85246     try {
85247       (arg1)->ApplyDefaultTheme();
85248     } catch (std::out_of_range& e) {
85249       {
85250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85251       };
85252     } catch (std::exception& e) {
85253       {
85254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85255       };
85256     } catch (Dali::DaliException e) {
85257       {
85258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85259       };
85260     } catch (...) {
85261       {
85262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85263       };
85264     }
85265   }
85266
85267 }
85268
85269
85270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85271   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85272   std::string *arg2 = 0 ;
85273   Dali::Property::Value *arg3 = 0 ;
85274
85275   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85276   if (!jarg2) {
85277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85278     return ;
85279   }
85280   std::string arg2_str(jarg2);
85281   arg2 = &arg2_str;
85282   arg3 = (Dali::Property::Value *)jarg3;
85283   if (!arg3) {
85284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
85285     return ;
85286   }
85287   {
85288     try {
85289       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
85290     } catch (std::out_of_range& e) {
85291       {
85292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85293       };
85294     } catch (std::exception& e) {
85295       {
85296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85297       };
85298     } catch (Dali::DaliException e) {
85299       {
85300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85301       };
85302     } catch (...) {
85303       {
85304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85305       };
85306     }
85307   }
85308
85309
85310   //argout typemap for const std::string&
85311
85312 }
85313
85314
85315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85316   unsigned int jresult ;
85317   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85318   std::string *arg2 = 0 ;
85319   Dali::Property::Value *arg3 = 0 ;
85320   bool result;
85321
85322   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85323   if (!jarg2) {
85324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85325     return 0;
85326   }
85327   std::string arg2_str(jarg2);
85328   arg2 = &arg2_str;
85329   arg3 = (Dali::Property::Value *)jarg3;
85330   if (!arg3) {
85331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
85332     return 0;
85333   }
85334   {
85335     try {
85336       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
85337     } catch (std::out_of_range& e) {
85338       {
85339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85340       };
85341     } catch (std::exception& e) {
85342       {
85343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85344       };
85345     } catch (Dali::DaliException e) {
85346       {
85347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85348       };
85349     } catch (...) {
85350       {
85351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85352       };
85353     }
85354   }
85355
85356   jresult = result;
85357
85358   //argout typemap for const std::string&
85359
85360   return jresult;
85361 }
85362
85363
85364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
85365   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85366   Dali::Toolkit::Control arg2 ;
85367   std::string *arg3 = 0 ;
85368   std::string *arg4 = 0 ;
85369   Dali::Toolkit::Control *argp2 ;
85370
85371   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85372   argp2 = (Dali::Toolkit::Control *)jarg2;
85373   if (!argp2) {
85374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
85375     return ;
85376   }
85377   arg2 = *argp2;
85378   if (!jarg3) {
85379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85380     return ;
85381   }
85382   std::string arg3_str(jarg3);
85383   arg3 = &arg3_str;
85384   if (!jarg4) {
85385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85386     return ;
85387   }
85388   std::string arg4_str(jarg4);
85389   arg4 = &arg4_str;
85390   {
85391     try {
85392       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
85393     } catch (std::out_of_range& e) {
85394       {
85395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85396       };
85397     } catch (std::exception& e) {
85398       {
85399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85400       };
85401     } catch (Dali::DaliException e) {
85402       {
85403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85404       };
85405     } catch (...) {
85406       {
85407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85408       };
85409     }
85410   }
85411
85412
85413   //argout typemap for const std::string&
85414
85415
85416   //argout typemap for const std::string&
85417
85418 }
85419
85420
85421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
85422   void * jresult ;
85423   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85424   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
85425
85426   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85427   {
85428     try {
85429       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
85430     } catch (std::out_of_range& e) {
85431       {
85432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85433       };
85434     } catch (std::exception& e) {
85435       {
85436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85437       };
85438     } catch (Dali::DaliException e) {
85439       {
85440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85441       };
85442     } catch (...) {
85443       {
85444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85445       };
85446     }
85447   }
85448
85449   jresult = (void *)result;
85450   return jresult;
85451 }
85452
85453
85454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
85455   int jresult ;
85456   int result;
85457
85458   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
85459   jresult = (int)result;
85460   return jresult;
85461 }
85462
85463
85464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
85465   int jresult ;
85466   int result;
85467
85468   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
85469   jresult = (int)result;
85470   return jresult;
85471 }
85472
85473
85474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
85475   int jresult ;
85476   int result;
85477
85478   result = (int)Dali::Toolkit::Slider::Property::VALUE;
85479   jresult = (int)result;
85480   return jresult;
85481 }
85482
85483
85484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
85485   int jresult ;
85486   int result;
85487
85488   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
85489   jresult = (int)result;
85490   return jresult;
85491 }
85492
85493
85494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
85495   int jresult ;
85496   int result;
85497
85498   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
85499   jresult = (int)result;
85500   return jresult;
85501 }
85502
85503
85504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
85505   int jresult ;
85506   int result;
85507
85508   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
85509   jresult = (int)result;
85510   return jresult;
85511 }
85512
85513
85514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
85515   int jresult ;
85516   int result;
85517
85518   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
85519   jresult = (int)result;
85520   return jresult;
85521 }
85522
85523
85524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
85525   int jresult ;
85526   int result;
85527
85528   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
85529   jresult = (int)result;
85530   return jresult;
85531 }
85532
85533
85534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
85535   int jresult ;
85536   int result;
85537
85538   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
85539   jresult = (int)result;
85540   return jresult;
85541 }
85542
85543
85544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
85545   int jresult ;
85546   int result;
85547
85548   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
85549   jresult = (int)result;
85550   return jresult;
85551 }
85552
85553
85554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
85555   int jresult ;
85556   int result;
85557
85558   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
85559   jresult = (int)result;
85560   return jresult;
85561 }
85562
85563
85564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
85565   int jresult ;
85566   int result;
85567
85568   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
85569   jresult = (int)result;
85570   return jresult;
85571 }
85572
85573
85574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
85575   int jresult ;
85576   int result;
85577
85578   result = (int)Dali::Toolkit::Slider::Property::MARKS;
85579   jresult = (int)result;
85580   return jresult;
85581 }
85582
85583
85584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
85585   int jresult ;
85586   int result;
85587
85588   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
85589   jresult = (int)result;
85590   return jresult;
85591 }
85592
85593
85594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
85595   int jresult ;
85596   int result;
85597
85598   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
85599   jresult = (int)result;
85600   return jresult;
85601 }
85602
85603
85604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
85605   void * jresult ;
85606   Dali::Toolkit::Slider::Property *result = 0 ;
85607
85608   {
85609     try {
85610       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
85611     } catch (std::out_of_range& e) {
85612       {
85613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85614       };
85615     } catch (std::exception& e) {
85616       {
85617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85618       };
85619     } catch (Dali::DaliException e) {
85620       {
85621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85622       };
85623     } catch (...) {
85624       {
85625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85626       };
85627     }
85628   }
85629
85630   jresult = (void *)result;
85631   return jresult;
85632 }
85633
85634
85635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
85636   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
85637
85638   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
85639   {
85640     try {
85641       delete arg1;
85642     } catch (std::out_of_range& e) {
85643       {
85644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85645       };
85646     } catch (std::exception& e) {
85647       {
85648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85649       };
85650     } catch (Dali::DaliException e) {
85651       {
85652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85653       };
85654     } catch (...) {
85655       {
85656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85657       };
85658     }
85659   }
85660
85661 }
85662
85663
85664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
85665   void * jresult ;
85666   Dali::Toolkit::Slider result;
85667
85668   {
85669     try {
85670       result = Dali::Toolkit::Slider::New();
85671     } catch (std::out_of_range& e) {
85672       {
85673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85674       };
85675     } catch (std::exception& e) {
85676       {
85677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85678       };
85679     } catch (Dali::DaliException e) {
85680       {
85681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85682       };
85683     } catch (...) {
85684       {
85685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85686       };
85687     }
85688   }
85689
85690   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85691   return jresult;
85692 }
85693
85694
85695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
85696   void * jresult ;
85697   Dali::Toolkit::Slider *result = 0 ;
85698
85699   {
85700     try {
85701       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
85702     } catch (std::out_of_range& e) {
85703       {
85704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85705       };
85706     } catch (std::exception& e) {
85707       {
85708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85709       };
85710     } catch (Dali::DaliException e) {
85711       {
85712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85713       };
85714     } catch (...) {
85715       {
85716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85717       };
85718     }
85719   }
85720
85721   jresult = (void *)result;
85722   return jresult;
85723 }
85724
85725
85726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
85727   void * jresult ;
85728   Dali::Toolkit::Slider *arg1 = 0 ;
85729   Dali::Toolkit::Slider *result = 0 ;
85730
85731   arg1 = (Dali::Toolkit::Slider *)jarg1;
85732   if (!arg1) {
85733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85734     return 0;
85735   }
85736   {
85737     try {
85738       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
85739     } catch (std::out_of_range& e) {
85740       {
85741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85742       };
85743     } catch (std::exception& e) {
85744       {
85745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85746       };
85747     } catch (Dali::DaliException e) {
85748       {
85749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85750       };
85751     } catch (...) {
85752       {
85753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85754       };
85755     }
85756   }
85757
85758   jresult = (void *)result;
85759   return jresult;
85760 }
85761
85762
85763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
85764   void * jresult ;
85765   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85766   Dali::Toolkit::Slider *arg2 = 0 ;
85767   Dali::Toolkit::Slider *result = 0 ;
85768
85769   arg1 = (Dali::Toolkit::Slider *)jarg1;
85770   arg2 = (Dali::Toolkit::Slider *)jarg2;
85771   if (!arg2) {
85772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85773     return 0;
85774   }
85775   {
85776     try {
85777       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
85778     } catch (std::out_of_range& e) {
85779       {
85780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85781       };
85782     } catch (std::exception& e) {
85783       {
85784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85785       };
85786     } catch (Dali::DaliException e) {
85787       {
85788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85789       };
85790     } catch (...) {
85791       {
85792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85793       };
85794     }
85795   }
85796
85797   jresult = (void *)result;
85798   return jresult;
85799 }
85800
85801
85802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
85803   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85804
85805   arg1 = (Dali::Toolkit::Slider *)jarg1;
85806   {
85807     try {
85808       delete arg1;
85809     } catch (std::out_of_range& e) {
85810       {
85811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85812       };
85813     } catch (std::exception& e) {
85814       {
85815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85816       };
85817     } catch (Dali::DaliException e) {
85818       {
85819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85820       };
85821     } catch (...) {
85822       {
85823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85824       };
85825     }
85826   }
85827
85828 }
85829
85830
85831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
85832   void * jresult ;
85833   Dali::BaseHandle arg1 ;
85834   Dali::BaseHandle *argp1 ;
85835   Dali::Toolkit::Slider result;
85836
85837   argp1 = (Dali::BaseHandle *)jarg1;
85838   if (!argp1) {
85839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85840     return 0;
85841   }
85842   arg1 = *argp1;
85843   {
85844     try {
85845       result = Dali::Toolkit::Slider::DownCast(arg1);
85846     } catch (std::out_of_range& e) {
85847       {
85848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85849       };
85850     } catch (std::exception& e) {
85851       {
85852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85853       };
85854     } catch (Dali::DaliException e) {
85855       {
85856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85857       };
85858     } catch (...) {
85859       {
85860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85861       };
85862     }
85863   }
85864
85865   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85866   return jresult;
85867 }
85868
85869
85870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
85871   void * jresult ;
85872   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85873   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85874
85875   arg1 = (Dali::Toolkit::Slider *)jarg1;
85876   {
85877     try {
85878       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
85879     } catch (std::out_of_range& e) {
85880       {
85881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85882       };
85883     } catch (std::exception& e) {
85884       {
85885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85886       };
85887     } catch (Dali::DaliException e) {
85888       {
85889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85890       };
85891     } catch (...) {
85892       {
85893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85894       };
85895     }
85896   }
85897
85898   jresult = (void *)result;
85899   return jresult;
85900 }
85901
85902
85903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
85904   void * jresult ;
85905   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85906   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85907
85908   arg1 = (Dali::Toolkit::Slider *)jarg1;
85909   {
85910     try {
85911       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
85912     } catch (std::out_of_range& e) {
85913       {
85914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85915       };
85916     } catch (std::exception& e) {
85917       {
85918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85919       };
85920     } catch (Dali::DaliException e) {
85921       {
85922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85923       };
85924     } catch (...) {
85925       {
85926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85927       };
85928     }
85929   }
85930
85931   jresult = (void *)result;
85932   return jresult;
85933 }
85934
85935
85936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
85937   void * jresult ;
85938   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85939   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
85940
85941   arg1 = (Dali::Toolkit::Slider *)jarg1;
85942   {
85943     try {
85944       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
85945     } catch (std::out_of_range& e) {
85946       {
85947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85948       };
85949     } catch (std::exception& e) {
85950       {
85951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85952       };
85953     } catch (Dali::DaliException e) {
85954       {
85955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85956       };
85957     } catch (...) {
85958       {
85959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85960       };
85961     }
85962   }
85963
85964   jresult = (void *)result;
85965   return jresult;
85966 }
85967
85968
85969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
85970   int jresult ;
85971   int result;
85972
85973   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
85974   jresult = (int)result;
85975   return jresult;
85976 }
85977
85978
85979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
85980   int jresult ;
85981   int result;
85982
85983   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
85984   jresult = (int)result;
85985   return jresult;
85986 }
85987
85988
85989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
85990   int jresult ;
85991   int result;
85992
85993   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
85994   jresult = (int)result;
85995   return jresult;
85996 }
85997
85998
85999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
86000   int jresult ;
86001   int result;
86002
86003   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
86004   jresult = (int)result;
86005   return jresult;
86006 }
86007
86008
86009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
86010   int result;
86011
86012   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
86013
86014   return result;
86015 }
86016
86017
86018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
86019   void * jresult ;
86020   Dali::Toolkit::VideoView::Property *result = 0 ;
86021
86022   {
86023     try {
86024       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
86025     } catch (std::out_of_range& e) {
86026       {
86027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86028       };
86029     } catch (std::exception& e) {
86030       {
86031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86032       };
86033     } catch (Dali::DaliException e) {
86034       {
86035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86036       };
86037     } catch (...) {
86038       {
86039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86040       };
86041     }
86042   }
86043
86044   jresult = (void *)result;
86045   return jresult;
86046 }
86047
86048
86049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
86050   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
86051
86052   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
86053   {
86054     try {
86055       delete arg1;
86056     } catch (std::out_of_range& e) {
86057       {
86058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86059       };
86060     } catch (std::exception& e) {
86061       {
86062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86063       };
86064     } catch (Dali::DaliException e) {
86065       {
86066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86067       };
86068     } catch (...) {
86069       {
86070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86071       };
86072     }
86073   }
86074
86075 }
86076
86077
86078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
86079   void * jresult ;
86080   Dali::Toolkit::VideoView result;
86081
86082   {
86083     try {
86084       result = Dali::Toolkit::VideoView::New();
86085     } catch (std::out_of_range& e) {
86086       {
86087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86088       };
86089     } catch (std::exception& e) {
86090       {
86091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86092       };
86093     } catch (Dali::DaliException e) {
86094       {
86095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86096       };
86097     } catch (...) {
86098       {
86099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86100       };
86101     }
86102   }
86103
86104   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86105   return jresult;
86106 }
86107
86108
86109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
86110   void * jresult ;
86111   std::string *arg1 = 0 ;
86112   Dali::Toolkit::VideoView result;
86113
86114   if (!jarg1) {
86115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86116     return 0;
86117   }
86118   std::string arg1_str(jarg1);
86119   arg1 = &arg1_str;
86120   {
86121     try {
86122       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
86123     } catch (std::out_of_range& e) {
86124       {
86125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86126       };
86127     } catch (std::exception& e) {
86128       {
86129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86130       };
86131     } catch (Dali::DaliException e) {
86132       {
86133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86134       };
86135     } catch (...) {
86136       {
86137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86138       };
86139     }
86140   }
86141
86142   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86143
86144   //argout typemap for const std::string&
86145
86146   return jresult;
86147 }
86148
86149
86150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
86151   void * jresult ;
86152   Dali::Toolkit::VideoView *result = 0 ;
86153
86154   {
86155     try {
86156       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
86157     } catch (std::out_of_range& e) {
86158       {
86159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86160       };
86161     } catch (std::exception& e) {
86162       {
86163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86164       };
86165     } catch (Dali::DaliException e) {
86166       {
86167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86168       };
86169     } catch (...) {
86170       {
86171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86172       };
86173     }
86174   }
86175
86176   jresult = (void *)result;
86177   return jresult;
86178 }
86179
86180
86181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
86182   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86183
86184   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86185   {
86186     try {
86187       delete arg1;
86188     } catch (std::out_of_range& e) {
86189       {
86190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86191       };
86192     } catch (std::exception& e) {
86193       {
86194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86195       };
86196     } catch (Dali::DaliException e) {
86197       {
86198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86199       };
86200     } catch (...) {
86201       {
86202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86203       };
86204     }
86205   }
86206
86207 }
86208
86209
86210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
86211   void * jresult ;
86212   Dali::Toolkit::VideoView *arg1 = 0 ;
86213   Dali::Toolkit::VideoView *result = 0 ;
86214
86215   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86216   if (!arg1) {
86217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86218     return 0;
86219   }
86220   {
86221     try {
86222       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
86223     } catch (std::out_of_range& e) {
86224       {
86225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86226       };
86227     } catch (std::exception& e) {
86228       {
86229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86230       };
86231     } catch (Dali::DaliException e) {
86232       {
86233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86234       };
86235     } catch (...) {
86236       {
86237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86238       };
86239     }
86240   }
86241
86242   jresult = (void *)result;
86243   return jresult;
86244 }
86245
86246
86247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
86248   void * jresult ;
86249   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86250   Dali::Toolkit::VideoView *arg2 = 0 ;
86251   Dali::Toolkit::VideoView *result = 0 ;
86252
86253   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86254   arg2 = (Dali::Toolkit::VideoView *)jarg2;
86255   if (!arg2) {
86256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86257     return 0;
86258   }
86259   {
86260     try {
86261       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
86262     } catch (std::out_of_range& e) {
86263       {
86264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86265       };
86266     } catch (std::exception& e) {
86267       {
86268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86269       };
86270     } catch (Dali::DaliException e) {
86271       {
86272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86273       };
86274     } catch (...) {
86275       {
86276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86277       };
86278     }
86279   }
86280
86281   jresult = (void *)result;
86282   return jresult;
86283 }
86284
86285
86286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
86287   void * jresult ;
86288   Dali::BaseHandle arg1 ;
86289   Dali::BaseHandle *argp1 ;
86290   Dali::Toolkit::VideoView result;
86291
86292   argp1 = (Dali::BaseHandle *)jarg1;
86293   if (!argp1) {
86294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86295     return 0;
86296   }
86297   arg1 = *argp1;
86298   {
86299     try {
86300       result = Dali::Toolkit::VideoView::DownCast(arg1);
86301     } catch (std::out_of_range& e) {
86302       {
86303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86304       };
86305     } catch (std::exception& e) {
86306       {
86307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86308       };
86309     } catch (Dali::DaliException e) {
86310       {
86311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86312       };
86313     } catch (...) {
86314       {
86315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86316       };
86317     }
86318   }
86319
86320   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86321   return jresult;
86322 }
86323
86324
86325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
86326   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86327
86328   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86329   {
86330     try {
86331       (arg1)->Play();
86332     } catch (std::out_of_range& e) {
86333       {
86334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86335       };
86336     } catch (std::exception& e) {
86337       {
86338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86339       };
86340     } catch (Dali::DaliException e) {
86341       {
86342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86343       };
86344     } catch (...) {
86345       {
86346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86347       };
86348     }
86349   }
86350
86351 }
86352
86353
86354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
86355   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86356
86357   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86358   {
86359     try {
86360       (arg1)->Pause();
86361     } catch (std::out_of_range& e) {
86362       {
86363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86364       };
86365     } catch (std::exception& e) {
86366       {
86367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86368       };
86369     } catch (Dali::DaliException e) {
86370       {
86371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86372       };
86373     } catch (...) {
86374       {
86375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86376       };
86377     }
86378   }
86379
86380 }
86381
86382
86383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
86384   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86385
86386   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86387   {
86388     try {
86389       (arg1)->Stop();
86390     } catch (std::out_of_range& e) {
86391       {
86392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86393       };
86394     } catch (std::exception& e) {
86395       {
86396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86397       };
86398     } catch (Dali::DaliException e) {
86399       {
86400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86401       };
86402     } catch (...) {
86403       {
86404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86405       };
86406     }
86407   }
86408
86409 }
86410
86411
86412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
86413   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86414   int arg2 ;
86415
86416   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86417   arg2 = (int)jarg2;
86418   {
86419     try {
86420       (arg1)->Forward(arg2);
86421     } catch (std::out_of_range& e) {
86422       {
86423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86424       };
86425     } catch (std::exception& e) {
86426       {
86427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86428       };
86429     } catch (Dali::DaliException e) {
86430       {
86431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86432       };
86433     } catch (...) {
86434       {
86435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86436       };
86437     }
86438   }
86439
86440 }
86441
86442
86443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
86444   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86445   int arg2 ;
86446
86447   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86448   arg2 = (int)jarg2;
86449   {
86450     try {
86451       (arg1)->Backward(arg2);
86452     } catch (std::out_of_range& e) {
86453       {
86454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86455       };
86456     } catch (std::exception& e) {
86457       {
86458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86459       };
86460     } catch (Dali::DaliException e) {
86461       {
86462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86463       };
86464     } catch (...) {
86465       {
86466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86467       };
86468     }
86469   }
86470
86471 }
86472
86473
86474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
86475   void * jresult ;
86476   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86477   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
86478
86479   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86480   {
86481     try {
86482       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
86483     } catch (std::out_of_range& e) {
86484       {
86485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86486       };
86487     } catch (std::exception& e) {
86488       {
86489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86490       };
86491     } catch (Dali::DaliException e) {
86492       {
86493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86494       };
86495     } catch (...) {
86496       {
86497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86498       };
86499     }
86500   }
86501
86502   jresult = (void *)result;
86503   return jresult;
86504 }
86505
86506
86507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
86508   int jresult ;
86509   int result;
86510
86511   result = (int)Dali::Toolkit::Popup::Property::TITLE;
86512   jresult = (int)result;
86513   return jresult;
86514 }
86515
86516
86517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
86518   int jresult ;
86519   int result;
86520
86521   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
86522   jresult = (int)result;
86523   return jresult;
86524 }
86525
86526
86527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
86528   int jresult ;
86529   int result;
86530
86531   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
86532   jresult = (int)result;
86533   return jresult;
86534 }
86535
86536
86537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
86538   int jresult ;
86539   int result;
86540
86541   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
86542   jresult = (int)result;
86543   return jresult;
86544 }
86545
86546
86547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
86548   int jresult ;
86549   int result;
86550
86551   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
86552   jresult = (int)result;
86553   return jresult;
86554 }
86555
86556
86557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
86558   int jresult ;
86559   int result;
86560
86561   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
86562   jresult = (int)result;
86563   return jresult;
86564 }
86565
86566
86567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
86568   int jresult ;
86569   int result;
86570
86571   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
86572   jresult = (int)result;
86573   return jresult;
86574 }
86575
86576
86577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
86578   int jresult ;
86579   int result;
86580
86581   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
86582   jresult = (int)result;
86583   return jresult;
86584 }
86585
86586
86587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
86588   int jresult ;
86589   int result;
86590
86591   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
86592   jresult = (int)result;
86593   return jresult;
86594 }
86595
86596
86597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
86598   int jresult ;
86599   int result;
86600
86601   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
86602   jresult = (int)result;
86603   return jresult;
86604 }
86605
86606
86607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
86608   int jresult ;
86609   int result;
86610
86611   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
86612   jresult = (int)result;
86613   return jresult;
86614 }
86615
86616
86617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
86618   int jresult ;
86619   int result;
86620
86621   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
86622   jresult = (int)result;
86623   return jresult;
86624 }
86625
86626
86627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
86628   int jresult ;
86629   int result;
86630
86631   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
86632   jresult = (int)result;
86633   return jresult;
86634 }
86635
86636
86637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
86638   int jresult ;
86639   int result;
86640
86641   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
86642   jresult = (int)result;
86643   return jresult;
86644 }
86645
86646
86647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
86648   int jresult ;
86649   int result;
86650
86651   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
86652   jresult = (int)result;
86653   return jresult;
86654 }
86655
86656
86657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
86658   int jresult ;
86659   int result;
86660
86661   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
86662   jresult = (int)result;
86663   return jresult;
86664 }
86665
86666
86667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
86668   int jresult ;
86669   int result;
86670
86671   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
86672   jresult = (int)result;
86673   return jresult;
86674 }
86675
86676
86677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
86678   int jresult ;
86679   int result;
86680
86681   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
86682   jresult = (int)result;
86683   return jresult;
86684 }
86685
86686
86687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
86688   int jresult ;
86689   int result;
86690
86691   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
86692   jresult = (int)result;
86693   return jresult;
86694 }
86695
86696
86697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
86698   int jresult ;
86699   int result;
86700
86701   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
86702   jresult = (int)result;
86703   return jresult;
86704 }
86705
86706
86707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
86708   int jresult ;
86709   int result;
86710
86711   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
86712   jresult = (int)result;
86713   return jresult;
86714 }
86715
86716
86717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
86718   void * jresult ;
86719   Dali::Toolkit::Popup::Property *result = 0 ;
86720
86721   {
86722     try {
86723       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
86724     } catch (std::out_of_range& e) {
86725       {
86726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86727       };
86728     } catch (std::exception& e) {
86729       {
86730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86731       };
86732     } catch (Dali::DaliException e) {
86733       {
86734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86735       };
86736     } catch (...) {
86737       {
86738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86739       };
86740     }
86741   }
86742
86743   jresult = (void *)result;
86744   return jresult;
86745 }
86746
86747
86748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
86749   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
86750
86751   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
86752   {
86753     try {
86754       delete arg1;
86755     } catch (std::out_of_range& e) {
86756       {
86757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86758       };
86759     } catch (std::exception& e) {
86760       {
86761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86762       };
86763     } catch (Dali::DaliException e) {
86764       {
86765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86766       };
86767     } catch (...) {
86768       {
86769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86770       };
86771     }
86772   }
86773
86774 }
86775
86776
86777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
86778   void * jresult ;
86779   Dali::Toolkit::Popup *result = 0 ;
86780
86781   {
86782     try {
86783       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
86784     } catch (std::out_of_range& e) {
86785       {
86786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86787       };
86788     } catch (std::exception& e) {
86789       {
86790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86791       };
86792     } catch (Dali::DaliException e) {
86793       {
86794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86795       };
86796     } catch (...) {
86797       {
86798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86799       };
86800     }
86801   }
86802
86803   jresult = (void *)result;
86804   return jresult;
86805 }
86806
86807
86808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
86809   void * jresult ;
86810   Dali::Toolkit::Popup result;
86811
86812   {
86813     try {
86814       result = Dali::Toolkit::Popup::New();
86815     } catch (std::out_of_range& e) {
86816       {
86817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86818       };
86819     } catch (std::exception& e) {
86820       {
86821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86822       };
86823     } catch (Dali::DaliException e) {
86824       {
86825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86826       };
86827     } catch (...) {
86828       {
86829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86830       };
86831     }
86832   }
86833
86834   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
86835   return jresult;
86836 }
86837
86838
86839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
86840   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86841
86842   arg1 = (Dali::Toolkit::Popup *)jarg1;
86843   {
86844     try {
86845       delete arg1;
86846     } catch (std::out_of_range& e) {
86847       {
86848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86849       };
86850     } catch (std::exception& e) {
86851       {
86852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86853       };
86854     } catch (Dali::DaliException e) {
86855       {
86856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86857       };
86858     } catch (...) {
86859       {
86860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86861       };
86862     }
86863   }
86864
86865 }
86866
86867
86868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
86869   void * jresult ;
86870   Dali::Toolkit::Popup *arg1 = 0 ;
86871   Dali::Toolkit::Popup *result = 0 ;
86872
86873   arg1 = (Dali::Toolkit::Popup *)jarg1;
86874   if (!arg1) {
86875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
86876     return 0;
86877   }
86878   {
86879     try {
86880       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
86881     } catch (std::out_of_range& e) {
86882       {
86883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86884       };
86885     } catch (std::exception& e) {
86886       {
86887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86888       };
86889     } catch (Dali::DaliException e) {
86890       {
86891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86892       };
86893     } catch (...) {
86894       {
86895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86896       };
86897     }
86898   }
86899
86900   jresult = (void *)result;
86901   return jresult;
86902 }
86903
86904
86905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
86906   void * jresult ;
86907   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86908   Dali::Toolkit::Popup *arg2 = 0 ;
86909   Dali::Toolkit::Popup *result = 0 ;
86910
86911   arg1 = (Dali::Toolkit::Popup *)jarg1;
86912   arg2 = (Dali::Toolkit::Popup *)jarg2;
86913   if (!arg2) {
86914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
86915     return 0;
86916   }
86917   {
86918     try {
86919       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
86920     } catch (std::out_of_range& e) {
86921       {
86922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86923       };
86924     } catch (std::exception& e) {
86925       {
86926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86927       };
86928     } catch (Dali::DaliException e) {
86929       {
86930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86931       };
86932     } catch (...) {
86933       {
86934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86935       };
86936     }
86937   }
86938
86939   jresult = (void *)result;
86940   return jresult;
86941 }
86942
86943
86944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
86945   void * jresult ;
86946   Dali::BaseHandle arg1 ;
86947   Dali::BaseHandle *argp1 ;
86948   Dali::Toolkit::Popup result;
86949
86950   argp1 = (Dali::BaseHandle *)jarg1;
86951   if (!argp1) {
86952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86953     return 0;
86954   }
86955   arg1 = *argp1;
86956   {
86957     try {
86958       result = Dali::Toolkit::Popup::DownCast(arg1);
86959     } catch (std::out_of_range& e) {
86960       {
86961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86962       };
86963     } catch (std::exception& e) {
86964       {
86965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86966       };
86967     } catch (Dali::DaliException e) {
86968       {
86969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86970       };
86971     } catch (...) {
86972       {
86973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86974       };
86975     }
86976   }
86977
86978   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
86979   return jresult;
86980 }
86981
86982
86983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
86984   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86985   Dali::Actor arg2 ;
86986   Dali::Actor *argp2 ;
86987
86988   arg1 = (Dali::Toolkit::Popup *)jarg1;
86989   argp2 = (Dali::Actor *)jarg2;
86990   if (!argp2) {
86991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86992     return ;
86993   }
86994   arg2 = *argp2;
86995   {
86996     try {
86997       (arg1)->SetTitle(arg2);
86998     } catch (std::out_of_range& e) {
86999       {
87000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87001       };
87002     } catch (std::exception& e) {
87003       {
87004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87005       };
87006     } catch (Dali::DaliException e) {
87007       {
87008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87009       };
87010     } catch (...) {
87011       {
87012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87013       };
87014     }
87015   }
87016
87017 }
87018
87019
87020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
87021   void * jresult ;
87022   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87023   Dali::Actor result;
87024
87025   arg1 = (Dali::Toolkit::Popup *)jarg1;
87026   {
87027     try {
87028       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
87029     } catch (std::out_of_range& e) {
87030       {
87031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87032       };
87033     } catch (std::exception& e) {
87034       {
87035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87036       };
87037     } catch (Dali::DaliException e) {
87038       {
87039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87040       };
87041     } catch (...) {
87042       {
87043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87044       };
87045     }
87046   }
87047
87048   jresult = new Dali::Actor((const Dali::Actor &)result);
87049   return jresult;
87050 }
87051
87052
87053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
87054   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87055   Dali::Actor arg2 ;
87056   Dali::Actor *argp2 ;
87057
87058   arg1 = (Dali::Toolkit::Popup *)jarg1;
87059   argp2 = (Dali::Actor *)jarg2;
87060   if (!argp2) {
87061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87062     return ;
87063   }
87064   arg2 = *argp2;
87065   {
87066     try {
87067       (arg1)->SetContent(arg2);
87068     } catch (std::out_of_range& e) {
87069       {
87070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87071       };
87072     } catch (std::exception& e) {
87073       {
87074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87075       };
87076     } catch (Dali::DaliException e) {
87077       {
87078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87079       };
87080     } catch (...) {
87081       {
87082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87083       };
87084     }
87085   }
87086
87087 }
87088
87089
87090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
87091   void * jresult ;
87092   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87093   Dali::Actor result;
87094
87095   arg1 = (Dali::Toolkit::Popup *)jarg1;
87096   {
87097     try {
87098       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
87099     } catch (std::out_of_range& e) {
87100       {
87101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87102       };
87103     } catch (std::exception& e) {
87104       {
87105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87106       };
87107     } catch (Dali::DaliException e) {
87108       {
87109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87110       };
87111     } catch (...) {
87112       {
87113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87114       };
87115     }
87116   }
87117
87118   jresult = new Dali::Actor((const Dali::Actor &)result);
87119   return jresult;
87120 }
87121
87122
87123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
87124   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87125   Dali::Actor arg2 ;
87126   Dali::Actor *argp2 ;
87127
87128   arg1 = (Dali::Toolkit::Popup *)jarg1;
87129   argp2 = (Dali::Actor *)jarg2;
87130   if (!argp2) {
87131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87132     return ;
87133   }
87134   arg2 = *argp2;
87135   {
87136     try {
87137       (arg1)->SetFooter(arg2);
87138     } catch (std::out_of_range& e) {
87139       {
87140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87141       };
87142     } catch (std::exception& e) {
87143       {
87144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87145       };
87146     } catch (Dali::DaliException e) {
87147       {
87148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87149       };
87150     } catch (...) {
87151       {
87152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87153       };
87154     }
87155   }
87156
87157 }
87158
87159
87160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
87161   void * jresult ;
87162   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87163   Dali::Actor result;
87164
87165   arg1 = (Dali::Toolkit::Popup *)jarg1;
87166   {
87167     try {
87168       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
87169     } catch (std::out_of_range& e) {
87170       {
87171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87172       };
87173     } catch (std::exception& e) {
87174       {
87175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87176       };
87177     } catch (Dali::DaliException e) {
87178       {
87179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87180       };
87181     } catch (...) {
87182       {
87183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87184       };
87185     }
87186   }
87187
87188   jresult = new Dali::Actor((const Dali::Actor &)result);
87189   return jresult;
87190 }
87191
87192
87193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
87194   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87195   Dali::Toolkit::Popup::DisplayState arg2 ;
87196
87197   arg1 = (Dali::Toolkit::Popup *)jarg1;
87198   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
87199   {
87200     try {
87201       (arg1)->SetDisplayState(arg2);
87202     } catch (std::out_of_range& e) {
87203       {
87204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87205       };
87206     } catch (std::exception& e) {
87207       {
87208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87209       };
87210     } catch (Dali::DaliException e) {
87211       {
87212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87213       };
87214     } catch (...) {
87215       {
87216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87217       };
87218     }
87219   }
87220
87221 }
87222
87223
87224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
87225   int jresult ;
87226   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87227   Dali::Toolkit::Popup::DisplayState result;
87228
87229   arg1 = (Dali::Toolkit::Popup *)jarg1;
87230   {
87231     try {
87232       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
87233     } catch (std::out_of_range& e) {
87234       {
87235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87236       };
87237     } catch (std::exception& e) {
87238       {
87239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87240       };
87241     } catch (Dali::DaliException e) {
87242       {
87243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87244       };
87245     } catch (...) {
87246       {
87247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87248       };
87249     }
87250   }
87251
87252   jresult = (int)result;
87253   return jresult;
87254 }
87255
87256
87257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
87258   void * jresult ;
87259   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87260   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
87261
87262   arg1 = (Dali::Toolkit::Popup *)jarg1;
87263   {
87264     try {
87265       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
87266     } catch (std::out_of_range& e) {
87267       {
87268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87269       };
87270     } catch (std::exception& e) {
87271       {
87272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87273       };
87274     } catch (Dali::DaliException e) {
87275       {
87276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87277       };
87278     } catch (...) {
87279       {
87280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87281       };
87282     }
87283   }
87284
87285   jresult = (void *)result;
87286   return jresult;
87287 }
87288
87289
87290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
87291   void * jresult ;
87292   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87293   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87294
87295   arg1 = (Dali::Toolkit::Popup *)jarg1;
87296   {
87297     try {
87298       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
87299     } catch (std::out_of_range& e) {
87300       {
87301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87302       };
87303     } catch (std::exception& e) {
87304       {
87305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87306       };
87307     } catch (Dali::DaliException e) {
87308       {
87309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87310       };
87311     } catch (...) {
87312       {
87313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87314       };
87315     }
87316   }
87317
87318   jresult = (void *)result;
87319   return jresult;
87320 }
87321
87322
87323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
87324   void * jresult ;
87325   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87326   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87327
87328   arg1 = (Dali::Toolkit::Popup *)jarg1;
87329   {
87330     try {
87331       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
87332     } catch (std::out_of_range& e) {
87333       {
87334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87335       };
87336     } catch (std::exception& e) {
87337       {
87338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87339       };
87340     } catch (Dali::DaliException e) {
87341       {
87342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87343       };
87344     } catch (...) {
87345       {
87346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87347       };
87348     }
87349   }
87350
87351   jresult = (void *)result;
87352   return jresult;
87353 }
87354
87355
87356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
87357   void * jresult ;
87358   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87359   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87360
87361   arg1 = (Dali::Toolkit::Popup *)jarg1;
87362   {
87363     try {
87364       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
87365     } catch (std::out_of_range& e) {
87366       {
87367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87368       };
87369     } catch (std::exception& e) {
87370       {
87371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87372       };
87373     } catch (Dali::DaliException e) {
87374       {
87375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87376       };
87377     } catch (...) {
87378       {
87379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87380       };
87381     }
87382   }
87383
87384   jresult = (void *)result;
87385   return jresult;
87386 }
87387
87388
87389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
87390   void * jresult ;
87391   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87392   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87393
87394   arg1 = (Dali::Toolkit::Popup *)jarg1;
87395   {
87396     try {
87397       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
87398     } catch (std::out_of_range& e) {
87399       {
87400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87401       };
87402     } catch (std::exception& e) {
87403       {
87404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87405       };
87406     } catch (Dali::DaliException e) {
87407       {
87408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87409       };
87410     } catch (...) {
87411       {
87412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87413       };
87414     }
87415   }
87416
87417   jresult = (void *)result;
87418   return jresult;
87419 }
87420
87421
87422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
87423   int jresult ;
87424   int result;
87425
87426   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
87427   jresult = (int)result;
87428   return jresult;
87429 }
87430
87431
87432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
87433   int jresult ;
87434   int result;
87435
87436   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
87437   jresult = (int)result;
87438   return jresult;
87439 }
87440
87441
87442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
87443   int jresult ;
87444   int result;
87445
87446   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
87447   jresult = (int)result;
87448   return jresult;
87449 }
87450
87451
87452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
87453   int jresult ;
87454   int result;
87455
87456   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
87457   jresult = (int)result;
87458   return jresult;
87459 }
87460
87461
87462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
87463   int jresult ;
87464   int result;
87465
87466   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
87467   jresult = (int)result;
87468   return jresult;
87469 }
87470
87471
87472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
87473   int jresult ;
87474   int result;
87475
87476   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
87477   jresult = (int)result;
87478   return jresult;
87479 }
87480
87481
87482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
87483   int jresult ;
87484   int result;
87485
87486   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
87487   jresult = (int)result;
87488   return jresult;
87489 }
87490
87491
87492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
87493   int jresult ;
87494   int result;
87495
87496   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
87497   jresult = (int)result;
87498   return jresult;
87499 }
87500
87501
87502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
87503   int jresult ;
87504   int result;
87505
87506   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
87507   jresult = (int)result;
87508   return jresult;
87509 }
87510
87511
87512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
87513   void * jresult ;
87514   Dali::Toolkit::ProgressBar::Property *result = 0 ;
87515
87516   {
87517     try {
87518       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
87519     } catch (std::out_of_range& e) {
87520       {
87521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87522       };
87523     } catch (std::exception& e) {
87524       {
87525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87526       };
87527     } catch (Dali::DaliException e) {
87528       {
87529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87530       };
87531     } catch (...) {
87532       {
87533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87534       };
87535     }
87536   }
87537
87538   jresult = (void *)result;
87539   return jresult;
87540 }
87541
87542
87543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
87544   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
87545
87546   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
87547   {
87548     try {
87549       delete arg1;
87550     } catch (std::out_of_range& e) {
87551       {
87552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87553       };
87554     } catch (std::exception& e) {
87555       {
87556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87557       };
87558     } catch (Dali::DaliException e) {
87559       {
87560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87561       };
87562     } catch (...) {
87563       {
87564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87565       };
87566     }
87567   }
87568
87569 }
87570
87571
87572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
87573   void * jresult ;
87574   Dali::Toolkit::ProgressBar result;
87575
87576   {
87577     try {
87578       result = Dali::Toolkit::ProgressBar::New();
87579     } catch (std::out_of_range& e) {
87580       {
87581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87582       };
87583     } catch (std::exception& e) {
87584       {
87585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87586       };
87587     } catch (Dali::DaliException e) {
87588       {
87589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87590       };
87591     } catch (...) {
87592       {
87593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87594       };
87595     }
87596   }
87597
87598   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87599   return jresult;
87600 }
87601
87602
87603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
87604   void * jresult ;
87605   Dali::Toolkit::ProgressBar *result = 0 ;
87606
87607   {
87608     try {
87609       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
87610     } catch (std::out_of_range& e) {
87611       {
87612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87613       };
87614     } catch (std::exception& e) {
87615       {
87616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87617       };
87618     } catch (Dali::DaliException e) {
87619       {
87620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87621       };
87622     } catch (...) {
87623       {
87624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87625       };
87626     }
87627   }
87628
87629   jresult = (void *)result;
87630   return jresult;
87631 }
87632
87633
87634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
87635   void * jresult ;
87636   Dali::Toolkit::ProgressBar *arg1 = 0 ;
87637   Dali::Toolkit::ProgressBar *result = 0 ;
87638
87639   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87640   if (!arg1) {
87641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87642     return 0;
87643   }
87644   {
87645     try {
87646       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
87647     } catch (std::out_of_range& e) {
87648       {
87649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87650       };
87651     } catch (std::exception& e) {
87652       {
87653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87654       };
87655     } catch (Dali::DaliException e) {
87656       {
87657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87658       };
87659     } catch (...) {
87660       {
87661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87662       };
87663     }
87664   }
87665
87666   jresult = (void *)result;
87667   return jresult;
87668 }
87669
87670
87671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
87672   void * jresult ;
87673   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87674   Dali::Toolkit::ProgressBar *arg2 = 0 ;
87675   Dali::Toolkit::ProgressBar *result = 0 ;
87676
87677   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87678   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
87679   if (!arg2) {
87680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87681     return 0;
87682   }
87683   {
87684     try {
87685       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
87686     } catch (std::out_of_range& e) {
87687       {
87688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87689       };
87690     } catch (std::exception& e) {
87691       {
87692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87693       };
87694     } catch (Dali::DaliException e) {
87695       {
87696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87697       };
87698     } catch (...) {
87699       {
87700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87701       };
87702     }
87703   }
87704
87705   jresult = (void *)result;
87706   return jresult;
87707 }
87708
87709
87710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
87711   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87712
87713   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87714   {
87715     try {
87716       delete arg1;
87717     } catch (std::out_of_range& e) {
87718       {
87719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87720       };
87721     } catch (std::exception& e) {
87722       {
87723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87724       };
87725     } catch (Dali::DaliException e) {
87726       {
87727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87728       };
87729     } catch (...) {
87730       {
87731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87732       };
87733     }
87734   }
87735
87736 }
87737
87738
87739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
87740   void * jresult ;
87741   Dali::BaseHandle arg1 ;
87742   Dali::BaseHandle *argp1 ;
87743   Dali::Toolkit::ProgressBar result;
87744
87745   argp1 = (Dali::BaseHandle *)jarg1;
87746   if (!argp1) {
87747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87748     return 0;
87749   }
87750   arg1 = *argp1;
87751   {
87752     try {
87753       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
87754     } catch (std::out_of_range& e) {
87755       {
87756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87757       };
87758     } catch (std::exception& e) {
87759       {
87760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87761       };
87762     } catch (Dali::DaliException e) {
87763       {
87764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87765       };
87766     } catch (...) {
87767       {
87768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87769       };
87770     }
87771   }
87772
87773   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87774   return jresult;
87775 }
87776
87777
87778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
87779   void * jresult ;
87780   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87781   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
87782
87783   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87784   {
87785     try {
87786       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87787     } catch (std::out_of_range& e) {
87788       {
87789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87790       };
87791     } catch (std::exception& e) {
87792       {
87793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87794       };
87795     } catch (Dali::DaliException e) {
87796       {
87797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87798       };
87799     } catch (...) {
87800       {
87801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87802       };
87803     }
87804   }
87805
87806   jresult = (void *)result;
87807   return jresult;
87808 }
87809
87810
87811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
87812   void * jresult ;
87813   Dali::Toolkit::GaussianBlurView *result = 0 ;
87814
87815   {
87816     try {
87817       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
87818     } catch (std::out_of_range& e) {
87819       {
87820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87821       };
87822     } catch (std::exception& e) {
87823       {
87824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87825       };
87826     } catch (Dali::DaliException e) {
87827       {
87828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87829       };
87830     } catch (...) {
87831       {
87832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87833       };
87834     }
87835   }
87836
87837   jresult = (void *)result;
87838   return jresult;
87839 }
87840
87841
87842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
87843   void * jresult ;
87844   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
87845   Dali::Toolkit::GaussianBlurView *result = 0 ;
87846
87847   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87848   if (!arg1) {
87849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
87850     return 0;
87851   }
87852   {
87853     try {
87854       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
87855     } catch (std::out_of_range& e) {
87856       {
87857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87858       };
87859     } catch (std::exception& e) {
87860       {
87861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87862       };
87863     } catch (Dali::DaliException e) {
87864       {
87865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87866       };
87867     } catch (...) {
87868       {
87869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87870       };
87871     }
87872   }
87873
87874   jresult = (void *)result;
87875   return jresult;
87876 }
87877
87878
87879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
87880   void * jresult ;
87881   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87882   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
87883   Dali::Toolkit::GaussianBlurView *result = 0 ;
87884
87885   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87886   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
87887   if (!arg2) {
87888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
87889     return 0;
87890   }
87891   {
87892     try {
87893       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
87894     } catch (std::out_of_range& e) {
87895       {
87896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87897       };
87898     } catch (std::exception& e) {
87899       {
87900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87901       };
87902     } catch (Dali::DaliException e) {
87903       {
87904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87905       };
87906     } catch (...) {
87907       {
87908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87909       };
87910     }
87911   }
87912
87913   jresult = (void *)result;
87914   return jresult;
87915 }
87916
87917
87918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
87919   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87920
87921   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87922   {
87923     try {
87924       delete arg1;
87925     } catch (std::out_of_range& e) {
87926       {
87927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87928       };
87929     } catch (std::exception& e) {
87930       {
87931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87932       };
87933     } catch (Dali::DaliException e) {
87934       {
87935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87936       };
87937     } catch (...) {
87938       {
87939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87940       };
87941     }
87942   }
87943
87944 }
87945
87946
87947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
87948   void * jresult ;
87949   Dali::BaseHandle arg1 ;
87950   Dali::BaseHandle *argp1 ;
87951   Dali::Toolkit::GaussianBlurView result;
87952
87953   argp1 = (Dali::BaseHandle *)jarg1;
87954   if (!argp1) {
87955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87956     return 0;
87957   }
87958   arg1 = *argp1;
87959   {
87960     try {
87961       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
87962     } catch (std::out_of_range& e) {
87963       {
87964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87965       };
87966     } catch (std::exception& e) {
87967       {
87968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87969       };
87970     } catch (Dali::DaliException e) {
87971       {
87972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87973       };
87974     } catch (...) {
87975       {
87976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87977       };
87978     }
87979   }
87980
87981   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
87982   return jresult;
87983 }
87984
87985
87986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
87987   void * jresult ;
87988   Dali::Toolkit::GaussianBlurView result;
87989
87990   {
87991     try {
87992       result = Dali::Toolkit::GaussianBlurView::New();
87993     } catch (std::out_of_range& e) {
87994       {
87995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87996       };
87997     } catch (std::exception& e) {
87998       {
87999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88000       };
88001     } catch (Dali::DaliException e) {
88002       {
88003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88004       };
88005     } catch (...) {
88006       {
88007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88008       };
88009     }
88010   }
88011
88012   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88013   return jresult;
88014 }
88015
88016
88017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
88018   void * jresult ;
88019   unsigned int arg1 ;
88020   float arg2 ;
88021   Dali::Pixel::Format arg3 ;
88022   float arg4 ;
88023   float arg5 ;
88024   bool arg6 ;
88025   Dali::Toolkit::GaussianBlurView result;
88026
88027   arg1 = (unsigned int)jarg1;
88028   arg2 = (float)jarg2;
88029   arg3 = (Dali::Pixel::Format)jarg3;
88030   arg4 = (float)jarg4;
88031   arg5 = (float)jarg5;
88032   arg6 = jarg6 ? true : false;
88033   {
88034     try {
88035       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
88036     } catch (std::out_of_range& e) {
88037       {
88038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88039       };
88040     } catch (std::exception& e) {
88041       {
88042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88043       };
88044     } catch (Dali::DaliException e) {
88045       {
88046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88047       };
88048     } catch (...) {
88049       {
88050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88051       };
88052     }
88053   }
88054
88055   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88056   return jresult;
88057 }
88058
88059
88060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
88061   void * jresult ;
88062   unsigned int arg1 ;
88063   float arg2 ;
88064   Dali::Pixel::Format arg3 ;
88065   float arg4 ;
88066   float arg5 ;
88067   Dali::Toolkit::GaussianBlurView result;
88068
88069   arg1 = (unsigned int)jarg1;
88070   arg2 = (float)jarg2;
88071   arg3 = (Dali::Pixel::Format)jarg3;
88072   arg4 = (float)jarg4;
88073   arg5 = (float)jarg5;
88074   {
88075     try {
88076       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
88077     } catch (std::out_of_range& e) {
88078       {
88079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88080       };
88081     } catch (std::exception& e) {
88082       {
88083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88084       };
88085     } catch (Dali::DaliException e) {
88086       {
88087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88088       };
88089     } catch (...) {
88090       {
88091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88092       };
88093     }
88094   }
88095
88096   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88097   return jresult;
88098 }
88099
88100
88101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
88102   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88103   Dali::Actor arg2 ;
88104   Dali::Actor *argp2 ;
88105
88106   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88107   argp2 = (Dali::Actor *)jarg2;
88108   if (!argp2) {
88109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88110     return ;
88111   }
88112   arg2 = *argp2;
88113   {
88114     try {
88115       (arg1)->Add(arg2);
88116     } catch (std::out_of_range& e) {
88117       {
88118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88119       };
88120     } catch (std::exception& e) {
88121       {
88122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88123       };
88124     } catch (Dali::DaliException e) {
88125       {
88126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88127       };
88128     } catch (...) {
88129       {
88130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88131       };
88132     }
88133   }
88134
88135 }
88136
88137
88138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
88139   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88140   Dali::Actor arg2 ;
88141   Dali::Actor *argp2 ;
88142
88143   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88144   argp2 = (Dali::Actor *)jarg2;
88145   if (!argp2) {
88146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88147     return ;
88148   }
88149   arg2 = *argp2;
88150   {
88151     try {
88152       (arg1)->Remove(arg2);
88153     } catch (std::out_of_range& e) {
88154       {
88155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88156       };
88157     } catch (std::exception& e) {
88158       {
88159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88160       };
88161     } catch (Dali::DaliException e) {
88162       {
88163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88164       };
88165     } catch (...) {
88166       {
88167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88168       };
88169     }
88170   }
88171
88172 }
88173
88174
88175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
88176   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88177
88178   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88179   {
88180     try {
88181       (arg1)->Activate();
88182     } catch (std::out_of_range& e) {
88183       {
88184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88185       };
88186     } catch (std::exception& e) {
88187       {
88188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88189       };
88190     } catch (Dali::DaliException e) {
88191       {
88192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88193       };
88194     } catch (...) {
88195       {
88196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88197       };
88198     }
88199   }
88200
88201 }
88202
88203
88204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
88205   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88206
88207   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88208   {
88209     try {
88210       (arg1)->ActivateOnce();
88211     } catch (std::out_of_range& e) {
88212       {
88213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88214       };
88215     } catch (std::exception& e) {
88216       {
88217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88218       };
88219     } catch (Dali::DaliException e) {
88220       {
88221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88222       };
88223     } catch (...) {
88224       {
88225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88226       };
88227     }
88228   }
88229
88230 }
88231
88232
88233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
88234   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88235
88236   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88237   {
88238     try {
88239       (arg1)->Deactivate();
88240     } catch (std::out_of_range& e) {
88241       {
88242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88243       };
88244     } catch (std::exception& e) {
88245       {
88246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88247       };
88248     } catch (Dali::DaliException e) {
88249       {
88250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88251       };
88252     } catch (...) {
88253       {
88254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88255       };
88256     }
88257   }
88258
88259 }
88260
88261
88262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
88263   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88264   Dali::Texture arg2 ;
88265   Dali::FrameBuffer arg3 ;
88266   Dali::Texture *argp2 ;
88267   Dali::FrameBuffer *argp3 ;
88268
88269   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88270   argp2 = (Dali::Texture *)jarg2;
88271   if (!argp2) {
88272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
88273     return ;
88274   }
88275   arg2 = *argp2;
88276   argp3 = (Dali::FrameBuffer *)jarg3;
88277   if (!argp3) {
88278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
88279     return ;
88280   }
88281   arg3 = *argp3;
88282   {
88283     try {
88284       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
88285     } catch (std::out_of_range& e) {
88286       {
88287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88288       };
88289     } catch (std::exception& e) {
88290       {
88291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88292       };
88293     } catch (Dali::DaliException e) {
88294       {
88295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88296       };
88297     } catch (...) {
88298       {
88299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88300       };
88301     }
88302   }
88303
88304 }
88305
88306
88307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
88308   int jresult ;
88309   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88310   Dali::Property::Index result;
88311
88312   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88313   {
88314     try {
88315       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
88316     } catch (std::out_of_range& e) {
88317       {
88318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88319       };
88320     } catch (std::exception& e) {
88321       {
88322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88323       };
88324     } catch (Dali::DaliException e) {
88325       {
88326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88327       };
88328     } catch (...) {
88329       {
88330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88331       };
88332     }
88333   }
88334
88335   jresult = result;
88336   return jresult;
88337 }
88338
88339
88340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
88341   void * jresult ;
88342   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88343   Dali::FrameBuffer result;
88344
88345   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88346   {
88347     try {
88348       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
88349     } catch (std::out_of_range& e) {
88350       {
88351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88352       };
88353     } catch (std::exception& e) {
88354       {
88355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88356       };
88357     } catch (Dali::DaliException e) {
88358       {
88359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88360       };
88361     } catch (...) {
88362       {
88363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88364       };
88365     }
88366   }
88367
88368   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
88369   return jresult;
88370 }
88371
88372
88373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
88374   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88375   Dali::Vector4 *arg2 = 0 ;
88376
88377   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88378   arg2 = (Dali::Vector4 *)jarg2;
88379   if (!arg2) {
88380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
88381     return ;
88382   }
88383   {
88384     try {
88385       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
88386     } catch (std::out_of_range& e) {
88387       {
88388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88389       };
88390     } catch (std::exception& e) {
88391       {
88392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88393       };
88394     } catch (Dali::DaliException e) {
88395       {
88396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88397       };
88398     } catch (...) {
88399       {
88400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88401       };
88402     }
88403   }
88404
88405 }
88406
88407
88408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
88409   void * jresult ;
88410   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88411   Dali::Vector4 result;
88412
88413   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88414   {
88415     try {
88416       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
88417     } catch (std::out_of_range& e) {
88418       {
88419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88420       };
88421     } catch (std::exception& e) {
88422       {
88423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88424       };
88425     } catch (Dali::DaliException e) {
88426       {
88427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88428       };
88429     } catch (...) {
88430       {
88431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88432       };
88433     }
88434   }
88435
88436   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
88437   return jresult;
88438 }
88439
88440
88441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
88442   void * jresult ;
88443   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88444   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
88445
88446   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88447   {
88448     try {
88449       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
88450     } catch (std::out_of_range& e) {
88451       {
88452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88453       };
88454     } catch (std::exception& e) {
88455       {
88456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88457       };
88458     } catch (Dali::DaliException e) {
88459       {
88460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88461       };
88462     } catch (...) {
88463       {
88464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88465       };
88466     }
88467   }
88468
88469   jresult = (void *)result;
88470   return jresult;
88471 }
88472
88473
88474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
88475   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88476
88477   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88478   {
88479     try {
88480       delete arg1;
88481     } catch (std::out_of_range& e) {
88482       {
88483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88484       };
88485     } catch (std::exception& e) {
88486       {
88487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88488       };
88489     } catch (Dali::DaliException e) {
88490       {
88491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88492       };
88493     } catch (...) {
88494       {
88495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88496       };
88497     }
88498   }
88499
88500 }
88501
88502
88503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
88504   unsigned int jresult ;
88505   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88506   unsigned int result;
88507
88508   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88509   {
88510     try {
88511       result = (unsigned int)(arg1)->GetNumberOfPages();
88512     } catch (std::out_of_range& e) {
88513       {
88514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88515       };
88516     } catch (std::exception& e) {
88517       {
88518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88519       };
88520     } catch (Dali::DaliException e) {
88521       {
88522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88523       };
88524     } catch (...) {
88525       {
88526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88527       };
88528     }
88529   }
88530
88531   jresult = result;
88532   return jresult;
88533 }
88534
88535
88536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
88537   void * jresult ;
88538   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88539   unsigned int arg2 ;
88540   Dali::Texture result;
88541
88542   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88543   arg2 = (unsigned int)jarg2;
88544   {
88545     try {
88546       result = (arg1)->NewPage(arg2);
88547     } catch (std::out_of_range& e) {
88548       {
88549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88550       };
88551     } catch (std::exception& e) {
88552       {
88553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88554       };
88555     } catch (Dali::DaliException e) {
88556       {
88557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88558       };
88559     } catch (...) {
88560       {
88561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88562       };
88563     }
88564   }
88565
88566   jresult = new Dali::Texture((const Dali::Texture &)result);
88567   return jresult;
88568 }
88569
88570
88571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
88572   int jresult ;
88573   int result;
88574
88575   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
88576   jresult = (int)result;
88577   return jresult;
88578 }
88579
88580
88581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
88582   int jresult ;
88583   int result;
88584
88585   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
88586   jresult = (int)result;
88587   return jresult;
88588 }
88589
88590
88591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
88592   int jresult ;
88593   int result;
88594
88595   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
88596   jresult = (int)result;
88597   return jresult;
88598 }
88599
88600
88601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
88602   void * jresult ;
88603   Dali::Toolkit::PageTurnView::Property *result = 0 ;
88604
88605   {
88606     try {
88607       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
88608     } catch (std::out_of_range& e) {
88609       {
88610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88611       };
88612     } catch (std::exception& e) {
88613       {
88614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88615       };
88616     } catch (Dali::DaliException e) {
88617       {
88618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88619       };
88620     } catch (...) {
88621       {
88622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88623       };
88624     }
88625   }
88626
88627   jresult = (void *)result;
88628   return jresult;
88629 }
88630
88631
88632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
88633   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
88634
88635   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
88636   {
88637     try {
88638       delete arg1;
88639     } catch (std::out_of_range& e) {
88640       {
88641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88642       };
88643     } catch (std::exception& e) {
88644       {
88645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88646       };
88647     } catch (Dali::DaliException e) {
88648       {
88649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88650       };
88651     } catch (...) {
88652       {
88653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88654       };
88655     }
88656   }
88657
88658 }
88659
88660
88661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
88662   void * jresult ;
88663   Dali::Toolkit::PageTurnView *result = 0 ;
88664
88665   {
88666     try {
88667       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
88668     } catch (std::out_of_range& e) {
88669       {
88670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88671       };
88672     } catch (std::exception& e) {
88673       {
88674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88675       };
88676     } catch (Dali::DaliException e) {
88677       {
88678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88679       };
88680     } catch (...) {
88681       {
88682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88683       };
88684     }
88685   }
88686
88687   jresult = (void *)result;
88688   return jresult;
88689 }
88690
88691
88692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
88693   void * jresult ;
88694   Dali::Toolkit::PageTurnView *arg1 = 0 ;
88695   Dali::Toolkit::PageTurnView *result = 0 ;
88696
88697   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88698   if (!arg1) {
88699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88700     return 0;
88701   }
88702   {
88703     try {
88704       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
88705     } catch (std::out_of_range& e) {
88706       {
88707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88708       };
88709     } catch (std::exception& e) {
88710       {
88711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88712       };
88713     } catch (Dali::DaliException e) {
88714       {
88715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88716       };
88717     } catch (...) {
88718       {
88719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88720       };
88721     }
88722   }
88723
88724   jresult = (void *)result;
88725   return jresult;
88726 }
88727
88728
88729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
88730   void * jresult ;
88731   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88732   Dali::Toolkit::PageTurnView *arg2 = 0 ;
88733   Dali::Toolkit::PageTurnView *result = 0 ;
88734
88735   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88736   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
88737   if (!arg2) {
88738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88739     return 0;
88740   }
88741   {
88742     try {
88743       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
88744     } catch (std::out_of_range& e) {
88745       {
88746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88747       };
88748     } catch (std::exception& e) {
88749       {
88750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88751       };
88752     } catch (Dali::DaliException e) {
88753       {
88754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88755       };
88756     } catch (...) {
88757       {
88758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88759       };
88760     }
88761   }
88762
88763   jresult = (void *)result;
88764   return jresult;
88765 }
88766
88767
88768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
88769   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88770
88771   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88772   {
88773     try {
88774       delete arg1;
88775     } catch (std::out_of_range& e) {
88776       {
88777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88778       };
88779     } catch (std::exception& e) {
88780       {
88781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88782       };
88783     } catch (Dali::DaliException e) {
88784       {
88785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88786       };
88787     } catch (...) {
88788       {
88789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88790       };
88791     }
88792   }
88793
88794 }
88795
88796
88797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
88798   void * jresult ;
88799   Dali::BaseHandle arg1 ;
88800   Dali::BaseHandle *argp1 ;
88801   Dali::Toolkit::PageTurnView result;
88802
88803   argp1 = (Dali::BaseHandle *)jarg1;
88804   if (!argp1) {
88805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88806     return 0;
88807   }
88808   arg1 = *argp1;
88809   {
88810     try {
88811       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
88812     } catch (std::out_of_range& e) {
88813       {
88814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88815       };
88816     } catch (std::exception& e) {
88817       {
88818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88819       };
88820     } catch (Dali::DaliException e) {
88821       {
88822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88823       };
88824     } catch (...) {
88825       {
88826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88827       };
88828     }
88829   }
88830
88831   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
88832   return jresult;
88833 }
88834
88835
88836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
88837   void * jresult ;
88838   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88839   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
88840
88841   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88842   {
88843     try {
88844       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
88845     } catch (std::out_of_range& e) {
88846       {
88847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88848       };
88849     } catch (std::exception& e) {
88850       {
88851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88852       };
88853     } catch (Dali::DaliException e) {
88854       {
88855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88856       };
88857     } catch (...) {
88858       {
88859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88860       };
88861     }
88862   }
88863
88864   jresult = (void *)result;
88865   return jresult;
88866 }
88867
88868
88869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
88870   void * jresult ;
88871   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88872   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
88873
88874   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88875   {
88876     try {
88877       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
88878     } catch (std::out_of_range& e) {
88879       {
88880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88881       };
88882     } catch (std::exception& e) {
88883       {
88884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88885       };
88886     } catch (Dali::DaliException e) {
88887       {
88888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88889       };
88890     } catch (...) {
88891       {
88892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88893       };
88894     }
88895   }
88896
88897   jresult = (void *)result;
88898   return jresult;
88899 }
88900
88901
88902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
88903   void * jresult ;
88904   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88905   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
88906
88907   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88908   {
88909     try {
88910       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
88911     } catch (std::out_of_range& e) {
88912       {
88913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88914       };
88915     } catch (std::exception& e) {
88916       {
88917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88918       };
88919     } catch (Dali::DaliException e) {
88920       {
88921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88922       };
88923     } catch (...) {
88924       {
88925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88926       };
88927     }
88928   }
88929
88930   jresult = (void *)result;
88931   return jresult;
88932 }
88933
88934
88935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
88936   void * jresult ;
88937   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88938   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
88939
88940   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88941   {
88942     try {
88943       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
88944     } catch (std::out_of_range& e) {
88945       {
88946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88947       };
88948     } catch (std::exception& e) {
88949       {
88950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88951       };
88952     } catch (Dali::DaliException e) {
88953       {
88954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88955       };
88956     } catch (...) {
88957       {
88958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88959       };
88960     }
88961   }
88962
88963   jresult = (void *)result;
88964   return jresult;
88965 }
88966
88967
88968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
88969   void * jresult ;
88970   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
88971
88972   {
88973     try {
88974       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
88975     } catch (std::out_of_range& e) {
88976       {
88977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88978       };
88979     } catch (std::exception& e) {
88980       {
88981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88982       };
88983     } catch (Dali::DaliException e) {
88984       {
88985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88986       };
88987     } catch (...) {
88988       {
88989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88990       };
88991     }
88992   }
88993
88994   jresult = (void *)result;
88995   return jresult;
88996 }
88997
88998
88999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
89000   void * jresult ;
89001   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
89002   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89003
89004   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89005   if (!arg1) {
89006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89007     return 0;
89008   }
89009   {
89010     try {
89011       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
89012     } catch (std::out_of_range& e) {
89013       {
89014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89015       };
89016     } catch (std::exception& e) {
89017       {
89018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89019       };
89020     } catch (Dali::DaliException e) {
89021       {
89022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89023       };
89024     } catch (...) {
89025       {
89026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89027       };
89028     }
89029   }
89030
89031   jresult = (void *)result;
89032   return jresult;
89033 }
89034
89035
89036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
89037   void * jresult ;
89038   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89039   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
89040   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89041
89042   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89043   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
89044   if (!arg2) {
89045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89046     return 0;
89047   }
89048   {
89049     try {
89050       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
89051     } catch (std::out_of_range& e) {
89052       {
89053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89054       };
89055     } catch (std::exception& e) {
89056       {
89057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89058       };
89059     } catch (Dali::DaliException e) {
89060       {
89061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89062       };
89063     } catch (...) {
89064       {
89065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89066       };
89067     }
89068   }
89069
89070   jresult = (void *)result;
89071   return jresult;
89072 }
89073
89074
89075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
89076   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89077
89078   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89079   {
89080     try {
89081       delete arg1;
89082     } catch (std::out_of_range& e) {
89083       {
89084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89085       };
89086     } catch (std::exception& e) {
89087       {
89088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89089       };
89090     } catch (Dali::DaliException e) {
89091       {
89092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89093       };
89094     } catch (...) {
89095       {
89096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89097       };
89098     }
89099   }
89100
89101 }
89102
89103
89104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
89105   void * jresult ;
89106   Dali::Toolkit::PageFactory *arg1 = 0 ;
89107   Dali::Vector2 *arg2 = 0 ;
89108   Dali::Toolkit::PageTurnLandscapeView result;
89109
89110   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89111   if (!arg1) {
89112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89113     return 0;
89114   }
89115   arg2 = (Dali::Vector2 *)jarg2;
89116   if (!arg2) {
89117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89118     return 0;
89119   }
89120   {
89121     try {
89122       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
89123     } catch (std::out_of_range& e) {
89124       {
89125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89126       };
89127     } catch (std::exception& e) {
89128       {
89129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89130       };
89131     } catch (Dali::DaliException e) {
89132       {
89133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89134       };
89135     } catch (...) {
89136       {
89137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89138       };
89139     }
89140   }
89141
89142   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89143   return jresult;
89144 }
89145
89146
89147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
89148   void * jresult ;
89149   Dali::BaseHandle arg1 ;
89150   Dali::BaseHandle *argp1 ;
89151   Dali::Toolkit::PageTurnLandscapeView result;
89152
89153   argp1 = (Dali::BaseHandle *)jarg1;
89154   if (!argp1) {
89155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89156     return 0;
89157   }
89158   arg1 = *argp1;
89159   {
89160     try {
89161       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
89162     } catch (std::out_of_range& e) {
89163       {
89164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89165       };
89166     } catch (std::exception& e) {
89167       {
89168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89169       };
89170     } catch (Dali::DaliException e) {
89171       {
89172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89173       };
89174     } catch (...) {
89175       {
89176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89177       };
89178     }
89179   }
89180
89181   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89182   return jresult;
89183 }
89184
89185
89186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
89187   void * jresult ;
89188   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89189
89190   {
89191     try {
89192       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
89193     } catch (std::out_of_range& e) {
89194       {
89195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89196       };
89197     } catch (std::exception& e) {
89198       {
89199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89200       };
89201     } catch (Dali::DaliException e) {
89202       {
89203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89204       };
89205     } catch (...) {
89206       {
89207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89208       };
89209     }
89210   }
89211
89212   jresult = (void *)result;
89213   return jresult;
89214 }
89215
89216
89217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
89218   void * jresult ;
89219   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
89220   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89221
89222   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89223   if (!arg1) {
89224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89225     return 0;
89226   }
89227   {
89228     try {
89229       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
89230     } catch (std::out_of_range& e) {
89231       {
89232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89233       };
89234     } catch (std::exception& e) {
89235       {
89236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89237       };
89238     } catch (Dali::DaliException e) {
89239       {
89240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89241       };
89242     } catch (...) {
89243       {
89244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89245       };
89246     }
89247   }
89248
89249   jresult = (void *)result;
89250   return jresult;
89251 }
89252
89253
89254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
89255   void * jresult ;
89256   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89257   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
89258   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89259
89260   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89261   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
89262   if (!arg2) {
89263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89264     return 0;
89265   }
89266   {
89267     try {
89268       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
89269     } catch (std::out_of_range& e) {
89270       {
89271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89272       };
89273     } catch (std::exception& e) {
89274       {
89275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89276       };
89277     } catch (Dali::DaliException e) {
89278       {
89279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89280       };
89281     } catch (...) {
89282       {
89283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89284       };
89285     }
89286   }
89287
89288   jresult = (void *)result;
89289   return jresult;
89290 }
89291
89292
89293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
89294   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89295
89296   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89297   {
89298     try {
89299       delete arg1;
89300     } catch (std::out_of_range& e) {
89301       {
89302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89303       };
89304     } catch (std::exception& e) {
89305       {
89306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89307       };
89308     } catch (Dali::DaliException e) {
89309       {
89310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89311       };
89312     } catch (...) {
89313       {
89314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89315       };
89316     }
89317   }
89318
89319 }
89320
89321
89322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
89323   void * jresult ;
89324   Dali::Toolkit::PageFactory *arg1 = 0 ;
89325   Dali::Vector2 *arg2 = 0 ;
89326   Dali::Toolkit::PageTurnPortraitView result;
89327
89328   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89329   if (!arg1) {
89330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89331     return 0;
89332   }
89333   arg2 = (Dali::Vector2 *)jarg2;
89334   if (!arg2) {
89335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89336     return 0;
89337   }
89338   {
89339     try {
89340       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
89341     } catch (std::out_of_range& e) {
89342       {
89343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89344       };
89345     } catch (std::exception& e) {
89346       {
89347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89348       };
89349     } catch (Dali::DaliException e) {
89350       {
89351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89352       };
89353     } catch (...) {
89354       {
89355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89356       };
89357     }
89358   }
89359
89360   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89361   return jresult;
89362 }
89363
89364
89365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
89366   void * jresult ;
89367   Dali::BaseHandle arg1 ;
89368   Dali::BaseHandle *argp1 ;
89369   Dali::Toolkit::PageTurnPortraitView result;
89370
89371   argp1 = (Dali::BaseHandle *)jarg1;
89372   if (!argp1) {
89373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89374     return 0;
89375   }
89376   arg1 = *argp1;
89377   {
89378     try {
89379       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
89380     } catch (std::out_of_range& e) {
89381       {
89382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89383       };
89384     } catch (std::exception& e) {
89385       {
89386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89387       };
89388     } catch (Dali::DaliException e) {
89389       {
89390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89391       };
89392     } catch (...) {
89393       {
89394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89395       };
89396     }
89397   }
89398
89399   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89400   return jresult;
89401 }
89402
89403
89404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
89405   int jresult ;
89406   int result;
89407
89408   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
89409   jresult = (int)result;
89410   return jresult;
89411 }
89412
89413
89414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
89415   int jresult ;
89416   int result;
89417
89418   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
89419   jresult = (int)result;
89420   return jresult;
89421 }
89422
89423
89424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
89425   int jresult ;
89426   int result;
89427
89428   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
89429   jresult = (int)result;
89430   return jresult;
89431 }
89432
89433
89434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
89435   void * jresult ;
89436   Dali::Toolkit::ToggleButton::Property *result = 0 ;
89437
89438   {
89439     try {
89440       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
89441     } catch (std::out_of_range& e) {
89442       {
89443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89444       };
89445     } catch (std::exception& e) {
89446       {
89447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89448       };
89449     } catch (Dali::DaliException e) {
89450       {
89451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89452       };
89453     } catch (...) {
89454       {
89455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89456       };
89457     }
89458   }
89459
89460   jresult = (void *)result;
89461   return jresult;
89462 }
89463
89464
89465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
89466   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
89467
89468   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
89469   {
89470     try {
89471       delete arg1;
89472     } catch (std::out_of_range& e) {
89473       {
89474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89475       };
89476     } catch (std::exception& e) {
89477       {
89478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89479       };
89480     } catch (Dali::DaliException e) {
89481       {
89482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89483       };
89484     } catch (...) {
89485       {
89486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89487       };
89488     }
89489   }
89490
89491 }
89492
89493
89494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
89495   void * jresult ;
89496   Dali::Toolkit::ToggleButton *result = 0 ;
89497
89498   {
89499     try {
89500       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
89501     } catch (std::out_of_range& e) {
89502       {
89503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89504       };
89505     } catch (std::exception& e) {
89506       {
89507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89508       };
89509     } catch (Dali::DaliException e) {
89510       {
89511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89512       };
89513     } catch (...) {
89514       {
89515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89516       };
89517     }
89518   }
89519
89520   jresult = (void *)result;
89521   return jresult;
89522 }
89523
89524
89525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
89526   void * jresult ;
89527   Dali::Toolkit::ToggleButton *arg1 = 0 ;
89528   Dali::Toolkit::ToggleButton *result = 0 ;
89529
89530   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89531   if (!arg1) {
89532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89533     return 0;
89534   }
89535   {
89536     try {
89537       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
89538     } catch (std::out_of_range& e) {
89539       {
89540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89541       };
89542     } catch (std::exception& e) {
89543       {
89544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89545       };
89546     } catch (Dali::DaliException e) {
89547       {
89548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89549       };
89550     } catch (...) {
89551       {
89552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89553       };
89554     }
89555   }
89556
89557   jresult = (void *)result;
89558   return jresult;
89559 }
89560
89561
89562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
89563   void * jresult ;
89564   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89565   Dali::Toolkit::ToggleButton *arg2 = 0 ;
89566   Dali::Toolkit::ToggleButton *result = 0 ;
89567
89568   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89569   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
89570   if (!arg2) {
89571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89572     return 0;
89573   }
89574   {
89575     try {
89576       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
89577     } catch (std::out_of_range& e) {
89578       {
89579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89580       };
89581     } catch (std::exception& e) {
89582       {
89583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89584       };
89585     } catch (Dali::DaliException e) {
89586       {
89587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89588       };
89589     } catch (...) {
89590       {
89591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89592       };
89593     }
89594   }
89595
89596   jresult = (void *)result;
89597   return jresult;
89598 }
89599
89600
89601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
89602   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89603
89604   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89605   {
89606     try {
89607       delete arg1;
89608     } catch (std::out_of_range& e) {
89609       {
89610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89611       };
89612     } catch (std::exception& e) {
89613       {
89614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89615       };
89616     } catch (Dali::DaliException e) {
89617       {
89618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89619       };
89620     } catch (...) {
89621       {
89622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89623       };
89624     }
89625   }
89626
89627 }
89628
89629
89630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
89631   void * jresult ;
89632   Dali::Toolkit::ToggleButton result;
89633
89634   {
89635     try {
89636       result = Dali::Toolkit::ToggleButton::New();
89637     } catch (std::out_of_range& e) {
89638       {
89639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89640       };
89641     } catch (std::exception& e) {
89642       {
89643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89644       };
89645     } catch (Dali::DaliException e) {
89646       {
89647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89648       };
89649     } catch (...) {
89650       {
89651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89652       };
89653     }
89654   }
89655
89656   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89657   return jresult;
89658 }
89659
89660
89661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
89662   void * jresult ;
89663   Dali::BaseHandle arg1 ;
89664   Dali::BaseHandle *argp1 ;
89665   Dali::Toolkit::ToggleButton result;
89666
89667   argp1 = (Dali::BaseHandle *)jarg1;
89668   if (!argp1) {
89669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89670     return 0;
89671   }
89672   arg1 = *argp1;
89673   {
89674     try {
89675       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
89676     } catch (std::out_of_range& e) {
89677       {
89678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89679       };
89680     } catch (std::exception& e) {
89681       {
89682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89683       };
89684     } catch (Dali::DaliException e) {
89685       {
89686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89687       };
89688     } catch (...) {
89689       {
89690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89691       };
89692     }
89693   }
89694
89695   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89696   return jresult;
89697 }
89698
89699
89700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
89701   void * jresult ;
89702   Dali::Toolkit::Visual::Base *result = 0 ;
89703
89704   {
89705     try {
89706       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
89707     } catch (std::out_of_range& e) {
89708       {
89709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89710       };
89711     } catch (std::exception& e) {
89712       {
89713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89714       };
89715     } catch (Dali::DaliException e) {
89716       {
89717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89718       };
89719     } catch (...) {
89720       {
89721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89722       };
89723     }
89724   }
89725
89726   jresult = (void *)result;
89727   return jresult;
89728 }
89729
89730
89731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
89732   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89733
89734   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89735   {
89736     try {
89737       delete arg1;
89738     } catch (std::out_of_range& e) {
89739       {
89740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89741       };
89742     } catch (std::exception& e) {
89743       {
89744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89745       };
89746     } catch (Dali::DaliException e) {
89747       {
89748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89749       };
89750     } catch (...) {
89751       {
89752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89753       };
89754     }
89755   }
89756
89757 }
89758
89759
89760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
89761   void * jresult ;
89762   Dali::Toolkit::Visual::Base *arg1 = 0 ;
89763   Dali::Toolkit::Visual::Base *result = 0 ;
89764
89765   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89766   if (!arg1) {
89767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
89768     return 0;
89769   }
89770   {
89771     try {
89772       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
89773     } catch (std::out_of_range& e) {
89774       {
89775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89776       };
89777     } catch (std::exception& e) {
89778       {
89779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89780       };
89781     } catch (Dali::DaliException e) {
89782       {
89783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89784       };
89785     } catch (...) {
89786       {
89787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89788       };
89789     }
89790   }
89791
89792   jresult = (void *)result;
89793   return jresult;
89794 }
89795
89796
89797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
89798   void * jresult ;
89799   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89800   Dali::Toolkit::Visual::Base *arg2 = 0 ;
89801   Dali::Toolkit::Visual::Base *result = 0 ;
89802
89803   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89804   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
89805   if (!arg2) {
89806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
89807     return 0;
89808   }
89809   {
89810     try {
89811       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
89812     } catch (std::out_of_range& e) {
89813       {
89814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89815       };
89816     } catch (std::exception& e) {
89817       {
89818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89819       };
89820     } catch (Dali::DaliException e) {
89821       {
89822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89823       };
89824     } catch (...) {
89825       {
89826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89827       };
89828     }
89829   }
89830
89831   jresult = (void *)result;
89832   return jresult;
89833 }
89834
89835
89836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
89837   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89838   std::string *arg2 = 0 ;
89839
89840   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89841   if (!jarg2) {
89842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89843     return ;
89844   }
89845   std::string arg2_str(jarg2);
89846   arg2 = &arg2_str;
89847   {
89848     try {
89849       (arg1)->SetName((std::string const &)*arg2);
89850     } catch (std::out_of_range& e) {
89851       {
89852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89853       };
89854     } catch (std::exception& e) {
89855       {
89856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89857       };
89858     } catch (Dali::DaliException e) {
89859       {
89860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89861       };
89862     } catch (...) {
89863       {
89864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89865       };
89866     }
89867   }
89868
89869
89870   //argout typemap for const std::string&
89871
89872 }
89873
89874
89875 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
89876   char * jresult ;
89877   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89878   std::string *result = 0 ;
89879
89880   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89881   {
89882     try {
89883       result = (std::string *) &(arg1)->GetName();
89884     } catch (std::out_of_range& e) {
89885       {
89886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89887       };
89888     } catch (std::exception& e) {
89889       {
89890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89891       };
89892     } catch (Dali::DaliException e) {
89893       {
89894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89895       };
89896     } catch (...) {
89897       {
89898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89899       };
89900     }
89901   }
89902
89903   jresult = SWIG_csharp_string_callback(result->c_str());
89904   return jresult;
89905 }
89906
89907
89908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
89909   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89910   Dali::Property::Map *arg2 = 0 ;
89911   Dali::Size arg3 ;
89912   Dali::Size *argp3 ;
89913
89914   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89915   arg2 = (Dali::Property::Map *)jarg2;
89916   if (!arg2) {
89917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
89918     return ;
89919   }
89920   argp3 = (Dali::Size *)jarg3;
89921   if (!argp3) {
89922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
89923     return ;
89924   }
89925   arg3 = *argp3;
89926   {
89927     try {
89928       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
89929     } catch (std::out_of_range& e) {
89930       {
89931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89932       };
89933     } catch (std::exception& e) {
89934       {
89935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89936       };
89937     } catch (Dali::DaliException e) {
89938       {
89939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89940       };
89941     } catch (...) {
89942       {
89943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89944       };
89945     }
89946   }
89947
89948 }
89949
89950
89951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
89952   float jresult ;
89953   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89954   float arg2 ;
89955   float result;
89956
89957   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89958   arg2 = (float)jarg2;
89959   {
89960     try {
89961       result = (float)(arg1)->GetHeightForWidth(arg2);
89962     } catch (std::out_of_range& e) {
89963       {
89964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89965       };
89966     } catch (std::exception& e) {
89967       {
89968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89969       };
89970     } catch (Dali::DaliException e) {
89971       {
89972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89973       };
89974     } catch (...) {
89975       {
89976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89977       };
89978     }
89979   }
89980
89981   jresult = result;
89982   return jresult;
89983 }
89984
89985
89986 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
89987   float jresult ;
89988   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89989   float arg2 ;
89990   float result;
89991
89992   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89993   arg2 = (float)jarg2;
89994   {
89995     try {
89996       result = (float)(arg1)->GetWidthForHeight(arg2);
89997     } catch (std::out_of_range& e) {
89998       {
89999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90000       };
90001     } catch (std::exception& e) {
90002       {
90003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90004       };
90005     } catch (Dali::DaliException e) {
90006       {
90007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90008       };
90009     } catch (...) {
90010       {
90011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90012       };
90013     }
90014   }
90015
90016   jresult = result;
90017   return jresult;
90018 }
90019
90020
90021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
90022   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90023   Dali::Vector2 *arg2 = 0 ;
90024
90025   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90026   arg2 = (Dali::Vector2 *)jarg2;
90027   if (!arg2) {
90028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
90029     return ;
90030   }
90031   {
90032     try {
90033       (arg1)->GetNaturalSize(*arg2);
90034     } catch (std::out_of_range& e) {
90035       {
90036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90037       };
90038     } catch (std::exception& e) {
90039       {
90040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90041       };
90042     } catch (Dali::DaliException e) {
90043       {
90044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90045       };
90046     } catch (...) {
90047       {
90048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90049       };
90050     }
90051   }
90052
90053 }
90054
90055
90056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
90057   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90058   float arg2 ;
90059
90060   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90061   arg2 = (int)jarg2;
90062   {
90063     try {
90064       (arg1)->SetDepthIndex(arg2);
90065     } catch (std::out_of_range& e) {
90066       {
90067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90068       };
90069     } catch (std::exception& e) {
90070       {
90071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90072       };
90073     } catch (Dali::DaliException e) {
90074       {
90075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90076       };
90077     } catch (...) {
90078       {
90079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90080       };
90081     }
90082   }
90083
90084 }
90085
90086
90087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
90088   int jresult ;
90089   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90090   int result;
90091
90092   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90093   {
90094     try {
90095       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
90096     } catch (std::out_of_range& e) {
90097       {
90098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90099       };
90100     } catch (std::exception& e) {
90101       {
90102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90103       };
90104     } catch (Dali::DaliException e) {
90105       {
90106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90107       };
90108     } catch (...) {
90109       {
90110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90111       };
90112     }
90113   }
90114
90115   jresult = result;
90116   return jresult;
90117 }
90118
90119
90120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
90121   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90122   Dali::Property::Map *arg2 = 0 ;
90123
90124   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90125   arg2 = (Dali::Property::Map *)jarg2;
90126   if (!arg2) {
90127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
90128     return ;
90129   }
90130   {
90131     try {
90132       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
90133     } catch (std::out_of_range& e) {
90134       {
90135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90136       };
90137     } catch (std::exception& e) {
90138       {
90139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90140       };
90141     } catch (Dali::DaliException e) {
90142       {
90143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90144       };
90145     } catch (...) {
90146       {
90147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90148       };
90149     }
90150   }
90151
90152 }
90153
90154
90155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
90156   void * jresult ;
90157   Dali::Toolkit::VisualFactory result;
90158
90159   {
90160     try {
90161       result = Dali::Toolkit::VisualFactory::Get();
90162     } catch (std::out_of_range& e) {
90163       {
90164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90165       };
90166     } catch (std::exception& e) {
90167       {
90168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90169       };
90170     } catch (Dali::DaliException e) {
90171       {
90172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90173       };
90174     } catch (...) {
90175       {
90176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90177       };
90178     }
90179   }
90180
90181   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
90182   return jresult;
90183 }
90184
90185
90186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
90187   void * jresult ;
90188   Dali::Toolkit::VisualFactory *result = 0 ;
90189
90190   {
90191     try {
90192       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
90193     } catch (std::out_of_range& e) {
90194       {
90195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90196       };
90197     } catch (std::exception& e) {
90198       {
90199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90200       };
90201     } catch (Dali::DaliException e) {
90202       {
90203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90204       };
90205     } catch (...) {
90206       {
90207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90208       };
90209     }
90210   }
90211
90212   jresult = (void *)result;
90213   return jresult;
90214 }
90215
90216
90217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
90218   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90219
90220   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90221   {
90222     try {
90223       delete arg1;
90224     } catch (std::out_of_range& e) {
90225       {
90226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90227       };
90228     } catch (std::exception& e) {
90229       {
90230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90231       };
90232     } catch (Dali::DaliException e) {
90233       {
90234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90235       };
90236     } catch (...) {
90237       {
90238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90239       };
90240     }
90241   }
90242
90243 }
90244
90245
90246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
90247   void * jresult ;
90248   Dali::Toolkit::VisualFactory *arg1 = 0 ;
90249   Dali::Toolkit::VisualFactory *result = 0 ;
90250
90251   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90252   if (!arg1) {
90253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90254     return 0;
90255   }
90256   {
90257     try {
90258       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
90259     } catch (std::out_of_range& e) {
90260       {
90261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90262       };
90263     } catch (std::exception& e) {
90264       {
90265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90266       };
90267     } catch (Dali::DaliException e) {
90268       {
90269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90270       };
90271     } catch (...) {
90272       {
90273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90274       };
90275     }
90276   }
90277
90278   jresult = (void *)result;
90279   return jresult;
90280 }
90281
90282
90283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
90284   void * jresult ;
90285   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90286   Dali::Toolkit::VisualFactory *arg2 = 0 ;
90287   Dali::Toolkit::VisualFactory *result = 0 ;
90288
90289   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90290   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
90291   if (!arg2) {
90292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90293     return 0;
90294   }
90295   {
90296     try {
90297       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
90298     } catch (std::out_of_range& e) {
90299       {
90300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90301       };
90302     } catch (std::exception& e) {
90303       {
90304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90305       };
90306     } catch (Dali::DaliException e) {
90307       {
90308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90309       };
90310     } catch (...) {
90311       {
90312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90313       };
90314     }
90315   }
90316
90317   jresult = (void *)result;
90318   return jresult;
90319 }
90320
90321
90322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
90323   void * jresult ;
90324   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90325   Dali::Property::Map *arg2 = 0 ;
90326   Dali::Toolkit::Visual::Base result;
90327
90328   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90329   arg2 = (Dali::Property::Map *)jarg2;
90330   if (!arg2) {
90331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90332     return 0;
90333   }
90334   {
90335     try {
90336       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
90337     } catch (std::out_of_range& e) {
90338       {
90339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90340       };
90341     } catch (std::exception& e) {
90342       {
90343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90344       };
90345     } catch (Dali::DaliException e) {
90346       {
90347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90348       };
90349     } catch (...) {
90350       {
90351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90352       };
90353     }
90354   }
90355
90356   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90357   return jresult;
90358 }
90359
90360
90361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
90362   void * jresult ;
90363   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90364   Dali::Image *arg2 = 0 ;
90365   Dali::Toolkit::Visual::Base result;
90366
90367   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90368   arg2 = (Dali::Image *)jarg2;
90369   if (!arg2) {
90370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
90371     return 0;
90372   }
90373   {
90374     try {
90375       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
90376     } catch (std::out_of_range& e) {
90377       {
90378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90379       };
90380     } catch (std::exception& e) {
90381       {
90382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90383       };
90384     } catch (Dali::DaliException e) {
90385       {
90386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90387       };
90388     } catch (...) {
90389       {
90390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90391       };
90392     }
90393   }
90394
90395   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90396   return jresult;
90397 }
90398
90399
90400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
90401   void * jresult ;
90402   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90403   std::string *arg2 = 0 ;
90404   Dali::ImageDimensions arg3 ;
90405   Dali::ImageDimensions *argp3 ;
90406   Dali::Toolkit::Visual::Base result;
90407
90408   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90409   if (!jarg2) {
90410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90411     return 0;
90412   }
90413   std::string arg2_str(jarg2);
90414   arg2 = &arg2_str;
90415   argp3 = (Dali::ImageDimensions *)jarg3;
90416   if (!argp3) {
90417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90418     return 0;
90419   }
90420   arg3 = *argp3;
90421   {
90422     try {
90423       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
90424     } catch (std::out_of_range& e) {
90425       {
90426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90427       };
90428     } catch (std::exception& e) {
90429       {
90430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90431       };
90432     } catch (Dali::DaliException e) {
90433       {
90434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90435       };
90436     } catch (...) {
90437       {
90438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90439       };
90440     }
90441   }
90442
90443   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90444
90445   //argout typemap for const std::string&
90446
90447   return jresult;
90448 }
90449
90450
90451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
90452   void * jresult ;
90453   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90454
90455   {
90456     try {
90457       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
90458     } catch (std::out_of_range& e) {
90459       {
90460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90461       };
90462     } catch (std::exception& e) {
90463       {
90464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90465       };
90466     } catch (Dali::DaliException e) {
90467       {
90468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90469       };
90470     } catch (...) {
90471       {
90472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90473       };
90474     }
90475   }
90476
90477   jresult = (void *)result;
90478   return jresult;
90479 }
90480
90481
90482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
90483   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90484
90485   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90486   {
90487     try {
90488       delete arg1;
90489     } catch (std::out_of_range& e) {
90490       {
90491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90492       };
90493     } catch (std::exception& e) {
90494       {
90495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90496       };
90497     } catch (Dali::DaliException e) {
90498       {
90499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90500       };
90501     } catch (...) {
90502       {
90503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90504       };
90505     }
90506   }
90507
90508 }
90509
90510
90511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
90512   void * jresult ;
90513   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
90514   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90515
90516   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90517   if (!arg1) {
90518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90519     return 0;
90520   }
90521   {
90522     try {
90523       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
90524     } catch (std::out_of_range& e) {
90525       {
90526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90527       };
90528     } catch (std::exception& e) {
90529       {
90530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90531       };
90532     } catch (Dali::DaliException e) {
90533       {
90534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90535       };
90536     } catch (...) {
90537       {
90538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90539       };
90540     }
90541   }
90542
90543   jresult = (void *)result;
90544   return jresult;
90545 }
90546
90547
90548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
90549   void * jresult ;
90550   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90551   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
90552   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90553
90554   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90555   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
90556   if (!arg2) {
90557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90558     return 0;
90559   }
90560   {
90561     try {
90562       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
90563     } catch (std::out_of_range& e) {
90564       {
90565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90566       };
90567     } catch (std::exception& e) {
90568       {
90569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90570       };
90571     } catch (Dali::DaliException e) {
90572       {
90573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90574       };
90575     } catch (...) {
90576       {
90577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90578       };
90579     }
90580   }
90581
90582   jresult = (void *)result;
90583   return jresult;
90584 }
90585
90586
90587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
90588   void * jresult ;
90589   Dali::Toolkit::AsyncImageLoader result;
90590
90591   {
90592     try {
90593       result = Dali::Toolkit::AsyncImageLoader::New();
90594     } catch (std::out_of_range& e) {
90595       {
90596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90597       };
90598     } catch (std::exception& e) {
90599       {
90600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90601       };
90602     } catch (Dali::DaliException e) {
90603       {
90604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90605       };
90606     } catch (...) {
90607       {
90608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90609       };
90610     }
90611   }
90612
90613   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90614   return jresult;
90615 }
90616
90617
90618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
90619   void * jresult ;
90620   Dali::BaseHandle arg1 ;
90621   Dali::BaseHandle *argp1 ;
90622   Dali::Toolkit::AsyncImageLoader result;
90623
90624   argp1 = (Dali::BaseHandle *)jarg1;
90625   if (!argp1) {
90626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90627     return 0;
90628   }
90629   arg1 = *argp1;
90630   {
90631     try {
90632       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
90633     } catch (std::out_of_range& e) {
90634       {
90635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90636       };
90637     } catch (std::exception& e) {
90638       {
90639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90640       };
90641     } catch (Dali::DaliException e) {
90642       {
90643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90644       };
90645     } catch (...) {
90646       {
90647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90648       };
90649     }
90650   }
90651
90652   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90653   return jresult;
90654 }
90655
90656
90657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
90658   unsigned int jresult ;
90659   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90660   std::string *arg2 = 0 ;
90661   uint32_t result;
90662
90663   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90664   if (!jarg2) {
90665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90666     return 0;
90667   }
90668   std::string arg2_str(jarg2);
90669   arg2 = &arg2_str;
90670   {
90671     try {
90672       result = (arg1)->Load((std::string const &)*arg2);
90673     } catch (std::out_of_range& e) {
90674       {
90675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90676       };
90677     } catch (std::exception& e) {
90678       {
90679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90680       };
90681     } catch (Dali::DaliException e) {
90682       {
90683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90684       };
90685     } catch (...) {
90686       {
90687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90688       };
90689     }
90690   }
90691
90692   jresult = result;
90693
90694   //argout typemap for const std::string&
90695
90696   return jresult;
90697 }
90698
90699
90700 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
90701   unsigned int jresult ;
90702   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90703   std::string *arg2 = 0 ;
90704   Dali::ImageDimensions arg3 ;
90705   Dali::ImageDimensions *argp3 ;
90706   uint32_t result;
90707
90708   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90709   if (!jarg2) {
90710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90711     return 0;
90712   }
90713   std::string arg2_str(jarg2);
90714   arg2 = &arg2_str;
90715   argp3 = (Dali::ImageDimensions *)jarg3;
90716   if (!argp3) {
90717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90718     return 0;
90719   }
90720   arg3 = *argp3;
90721   {
90722     try {
90723       result = (arg1)->Load((std::string const &)*arg2,arg3);
90724     } catch (std::out_of_range& e) {
90725       {
90726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90727       };
90728     } catch (std::exception& e) {
90729       {
90730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90731       };
90732     } catch (Dali::DaliException e) {
90733       {
90734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90735       };
90736     } catch (...) {
90737       {
90738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90739       };
90740     }
90741   }
90742
90743   jresult = result;
90744
90745   //argout typemap for const std::string&
90746
90747   return jresult;
90748 }
90749
90750
90751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
90752   unsigned int jresult ;
90753   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90754   std::string *arg2 = 0 ;
90755   Dali::ImageDimensions arg3 ;
90756   Dali::FittingMode::Type arg4 ;
90757   Dali::SamplingMode::Type arg5 ;
90758   bool arg6 ;
90759   Dali::ImageDimensions *argp3 ;
90760   uint32_t result;
90761
90762   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90763   if (!jarg2) {
90764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90765     return 0;
90766   }
90767   std::string arg2_str(jarg2);
90768   arg2 = &arg2_str;
90769   argp3 = (Dali::ImageDimensions *)jarg3;
90770   if (!argp3) {
90771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90772     return 0;
90773   }
90774   arg3 = *argp3;
90775   arg4 = (Dali::FittingMode::Type)jarg4;
90776   arg5 = (Dali::SamplingMode::Type)jarg5;
90777   arg6 = jarg6 ? true : false;
90778   {
90779     try {
90780       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
90781     } catch (std::out_of_range& e) {
90782       {
90783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90784       };
90785     } catch (std::exception& e) {
90786       {
90787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90788       };
90789     } catch (Dali::DaliException e) {
90790       {
90791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90792       };
90793     } catch (...) {
90794       {
90795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90796       };
90797     }
90798   }
90799
90800   jresult = result;
90801
90802   //argout typemap for const std::string&
90803
90804   return jresult;
90805 }
90806
90807
90808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
90809   unsigned int jresult ;
90810   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90811   uint32_t arg2 ;
90812   bool result;
90813
90814   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90815   arg2 = (uint32_t)jarg2;
90816   {
90817     try {
90818       result = (bool)(arg1)->Cancel(arg2);
90819     } catch (std::out_of_range& e) {
90820       {
90821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90822       };
90823     } catch (std::exception& e) {
90824       {
90825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90826       };
90827     } catch (Dali::DaliException e) {
90828       {
90829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90830       };
90831     } catch (...) {
90832       {
90833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90834       };
90835     }
90836   }
90837
90838   jresult = result;
90839   return jresult;
90840 }
90841
90842
90843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
90844   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90845
90846   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90847   {
90848     try {
90849       (arg1)->CancelAll();
90850     } catch (std::out_of_range& e) {
90851       {
90852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90853       };
90854     } catch (std::exception& e) {
90855       {
90856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90857       };
90858     } catch (Dali::DaliException e) {
90859       {
90860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90861       };
90862     } catch (...) {
90863       {
90864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90865       };
90866     }
90867   }
90868
90869 }
90870
90871
90872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
90873   void * jresult ;
90874   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90875   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
90876
90877   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90878   {
90879     try {
90880       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
90881     } catch (std::out_of_range& e) {
90882       {
90883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90884       };
90885     } catch (std::exception& e) {
90886       {
90887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90888       };
90889     } catch (Dali::DaliException e) {
90890       {
90891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90892       };
90893     } catch (...) {
90894       {
90895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90896       };
90897     }
90898   }
90899
90900   jresult = (void *)result;
90901   return jresult;
90902 }
90903
90904
90905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
90906   void * jresult ;
90907   std::string *arg1 = 0 ;
90908   Dali::PixelData result;
90909
90910   if (!jarg1) {
90911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90912     return 0;
90913   }
90914   std::string arg1_str(jarg1);
90915   arg1 = &arg1_str;
90916   {
90917     try {
90918       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
90919     } catch (std::out_of_range& e) {
90920       {
90921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90922       };
90923     } catch (std::exception& e) {
90924       {
90925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90926       };
90927     } catch (Dali::DaliException e) {
90928       {
90929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90930       };
90931     } catch (...) {
90932       {
90933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90934       };
90935     }
90936   }
90937
90938   jresult = new Dali::PixelData((const Dali::PixelData &)result);
90939
90940   //argout typemap for const std::string&
90941
90942   return jresult;
90943 }
90944
90945
90946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
90947   void * jresult ;
90948   std::string *arg1 = 0 ;
90949   Dali::ImageDimensions arg2 ;
90950   Dali::ImageDimensions *argp2 ;
90951   Dali::PixelData result;
90952
90953   if (!jarg1) {
90954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90955     return 0;
90956   }
90957   std::string arg1_str(jarg1);
90958   arg1 = &arg1_str;
90959   argp2 = (Dali::ImageDimensions *)jarg2;
90960   if (!argp2) {
90961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90962     return 0;
90963   }
90964   arg2 = *argp2;
90965   {
90966     try {
90967       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
90968     } catch (std::out_of_range& e) {
90969       {
90970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90971       };
90972     } catch (std::exception& e) {
90973       {
90974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90975       };
90976     } catch (Dali::DaliException e) {
90977       {
90978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90979       };
90980     } catch (...) {
90981       {
90982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90983       };
90984     }
90985   }
90986
90987   jresult = new Dali::PixelData((const Dali::PixelData &)result);
90988
90989   //argout typemap for const std::string&
90990
90991   return jresult;
90992 }
90993
90994
90995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
90996   void * jresult ;
90997   std::string *arg1 = 0 ;
90998   Dali::ImageDimensions arg2 ;
90999   Dali::FittingMode::Type arg3 ;
91000   Dali::SamplingMode::Type arg4 ;
91001   bool arg5 ;
91002   Dali::ImageDimensions *argp2 ;
91003   Dali::PixelData result;
91004
91005   if (!jarg1) {
91006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91007     return 0;
91008   }
91009   std::string arg1_str(jarg1);
91010   arg1 = &arg1_str;
91011   argp2 = (Dali::ImageDimensions *)jarg2;
91012   if (!argp2) {
91013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91014     return 0;
91015   }
91016   arg2 = *argp2;
91017   arg3 = (Dali::FittingMode::Type)jarg3;
91018   arg4 = (Dali::SamplingMode::Type)jarg4;
91019   arg5 = jarg5 ? true : false;
91020   {
91021     try {
91022       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
91023     } catch (std::out_of_range& e) {
91024       {
91025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91026       };
91027     } catch (std::exception& e) {
91028       {
91029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91030       };
91031     } catch (Dali::DaliException e) {
91032       {
91033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91034       };
91035     } catch (...) {
91036       {
91037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91038       };
91039     }
91040   }
91041
91042   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91043
91044   //argout typemap for const std::string&
91045
91046   return jresult;
91047 }
91048
91049
91050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
91051   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91052
91053   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91054   {
91055     try {
91056       delete arg1;
91057     } catch (std::out_of_range& e) {
91058       {
91059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91060       };
91061     } catch (std::exception& e) {
91062       {
91063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91064       };
91065     } catch (Dali::DaliException e) {
91066       {
91067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91068       };
91069     } catch (...) {
91070       {
91071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91072       };
91073     }
91074   }
91075
91076 }
91077
91078
91079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
91080   void * jresult ;
91081   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91082   Dali::Actor arg2 ;
91083   Dali::Actor arg3 ;
91084   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
91085   Dali::Actor *argp2 ;
91086   Dali::Actor *argp3 ;
91087   Dali::Actor result;
91088
91089   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91090   argp2 = (Dali::Actor *)jarg2;
91091   if (!argp2) {
91092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91093     return 0;
91094   }
91095   arg2 = *argp2;
91096   argp3 = (Dali::Actor *)jarg3;
91097   if (!argp3) {
91098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91099     return 0;
91100   }
91101   arg3 = *argp3;
91102   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
91103   {
91104     try {
91105       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
91106     } catch (std::out_of_range& e) {
91107       {
91108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91109       };
91110     } catch (std::exception& e) {
91111       {
91112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91113       };
91114     } catch (Dali::DaliException e) {
91115       {
91116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91117       };
91118     } catch (...) {
91119       {
91120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91121       };
91122     }
91123   }
91124
91125   jresult = new Dali::Actor((const Dali::Actor &)result);
91126   return jresult;
91127 }
91128
91129
91130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
91131   void * jresult ;
91132   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
91133
91134   {
91135     try {
91136       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
91137     } catch (std::out_of_range& e) {
91138       {
91139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91140       };
91141     } catch (std::exception& e) {
91142       {
91143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91144       };
91145     } catch (Dali::DaliException e) {
91146       {
91147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91148       };
91149     } catch (...) {
91150       {
91151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91152       };
91153     }
91154   }
91155
91156   jresult = (void *)result;
91157   return jresult;
91158 }
91159
91160
91161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
91162   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
91163   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
91164   if (director) {
91165     director->swig_connect_director(callback0);
91166   }
91167 }
91168
91169
91170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
91171   KeyboardFocusManager arg1 ;
91172   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
91173   KeyboardFocusManager *argp1 ;
91174
91175   argp1 = (KeyboardFocusManager *)jarg1;
91176   if (!argp1) {
91177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
91178     return ;
91179   }
91180   arg1 = *argp1;
91181   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
91182   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
91183   {
91184     try {
91185       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
91186     } catch (std::out_of_range& e) {
91187       {
91188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91189       };
91190     } catch (std::exception& e) {
91191       {
91192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91193       };
91194     } catch (Dali::DaliException e) {
91195       {
91196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91197       };
91198     } catch (...) {
91199       {
91200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91201       };
91202     }
91203   }
91204
91205 }
91206
91207
91208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
91209   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91210
91211   arg1 = (std::vector< unsigned int > *)jarg1;
91212   {
91213     try {
91214       (arg1)->clear();
91215     } catch (std::out_of_range& e) {
91216       {
91217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91218       };
91219     } catch (std::exception& e) {
91220       {
91221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91222       };
91223     } catch (Dali::DaliException e) {
91224       {
91225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91226       };
91227     } catch (...) {
91228       {
91229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91230       };
91231     }
91232   }
91233
91234 }
91235
91236
91237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
91238   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91239   unsigned int *arg2 = 0 ;
91240   unsigned int temp2 ;
91241
91242   arg1 = (std::vector< unsigned int > *)jarg1;
91243   temp2 = (unsigned int)jarg2;
91244   arg2 = &temp2;
91245   {
91246     try {
91247       (arg1)->push_back((unsigned int const &)*arg2);
91248     } catch (std::out_of_range& e) {
91249       {
91250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91251       };
91252     } catch (std::exception& e) {
91253       {
91254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91255       };
91256     } catch (Dali::DaliException e) {
91257       {
91258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91259       };
91260     } catch (...) {
91261       {
91262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91263       };
91264     }
91265   }
91266
91267 }
91268
91269
91270 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
91271   unsigned long jresult ;
91272   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91273   std::vector< unsigned int >::size_type result;
91274
91275   arg1 = (std::vector< unsigned int > *)jarg1;
91276   {
91277     try {
91278       result = ((std::vector< unsigned int > const *)arg1)->size();
91279     } catch (std::out_of_range& e) {
91280       {
91281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91282       };
91283     } catch (std::exception& e) {
91284       {
91285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91286       };
91287     } catch (Dali::DaliException e) {
91288       {
91289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91290       };
91291     } catch (...) {
91292       {
91293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91294       };
91295     }
91296   }
91297
91298   jresult = (unsigned long)result;
91299   return jresult;
91300 }
91301
91302
91303 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
91304   unsigned long jresult ;
91305   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91306   std::vector< unsigned int >::size_type result;
91307
91308   arg1 = (std::vector< unsigned int > *)jarg1;
91309   {
91310     try {
91311       result = ((std::vector< unsigned int > const *)arg1)->capacity();
91312     } catch (std::out_of_range& e) {
91313       {
91314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91315       };
91316     } catch (std::exception& e) {
91317       {
91318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91319       };
91320     } catch (Dali::DaliException e) {
91321       {
91322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91323       };
91324     } catch (...) {
91325       {
91326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91327       };
91328     }
91329   }
91330
91331   jresult = (unsigned long)result;
91332   return jresult;
91333 }
91334
91335
91336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
91337   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91338   std::vector< unsigned int >::size_type arg2 ;
91339
91340   arg1 = (std::vector< unsigned int > *)jarg1;
91341   arg2 = (std::vector< unsigned int >::size_type)jarg2;
91342   {
91343     try {
91344       (arg1)->reserve(arg2);
91345     } catch (std::out_of_range& e) {
91346       {
91347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91348       };
91349     } catch (std::exception& e) {
91350       {
91351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91352       };
91353     } catch (Dali::DaliException e) {
91354       {
91355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91356       };
91357     } catch (...) {
91358       {
91359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91360       };
91361     }
91362   }
91363
91364 }
91365
91366
91367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
91368   void * jresult ;
91369   std::vector< unsigned int > *result = 0 ;
91370
91371   {
91372     try {
91373       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
91374     } catch (std::out_of_range& e) {
91375       {
91376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91377       };
91378     } catch (std::exception& e) {
91379       {
91380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91381       };
91382     } catch (Dali::DaliException e) {
91383       {
91384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91385       };
91386     } catch (...) {
91387       {
91388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91389       };
91390     }
91391   }
91392
91393   jresult = (void *)result;
91394   return jresult;
91395 }
91396
91397
91398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
91399   void * jresult ;
91400   std::vector< unsigned int > *arg1 = 0 ;
91401   std::vector< unsigned int > *result = 0 ;
91402
91403   arg1 = (std::vector< unsigned int > *)jarg1;
91404   if (!arg1) {
91405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91406     return 0;
91407   }
91408   {
91409     try {
91410       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
91411     } catch (std::out_of_range& e) {
91412       {
91413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91414       };
91415     } catch (std::exception& e) {
91416       {
91417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91418       };
91419     } catch (Dali::DaliException e) {
91420       {
91421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91422       };
91423     } catch (...) {
91424       {
91425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91426       };
91427     }
91428   }
91429
91430   jresult = (void *)result;
91431   return jresult;
91432 }
91433
91434
91435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
91436   void * jresult ;
91437   int arg1 ;
91438   std::vector< unsigned int > *result = 0 ;
91439
91440   arg1 = (int)jarg1;
91441   {
91442     try {
91443       try {
91444         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
91445       }
91446       catch(std::out_of_range &_e) {
91447         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91448         return 0;
91449       }
91450
91451     } catch (std::out_of_range& e) {
91452       {
91453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91454       };
91455     } catch (std::exception& e) {
91456       {
91457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91458       };
91459     } catch (Dali::DaliException e) {
91460       {
91461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91462       };
91463     } catch (...) {
91464       {
91465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91466       };
91467     }
91468   }
91469
91470   jresult = (void *)result;
91471   return jresult;
91472 }
91473
91474
91475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
91476   unsigned int jresult ;
91477   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91478   int arg2 ;
91479   unsigned int result;
91480
91481   arg1 = (std::vector< unsigned int > *)jarg1;
91482   arg2 = (int)jarg2;
91483   {
91484     try {
91485       try {
91486         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
91487       }
91488       catch(std::out_of_range &_e) {
91489         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91490         return 0;
91491       }
91492
91493     } catch (std::out_of_range& e) {
91494       {
91495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91496       };
91497     } catch (std::exception& e) {
91498       {
91499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91500       };
91501     } catch (Dali::DaliException e) {
91502       {
91503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91504       };
91505     } catch (...) {
91506       {
91507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91508       };
91509     }
91510   }
91511
91512   jresult = result;
91513   return jresult;
91514 }
91515
91516
91517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
91518   unsigned int jresult ;
91519   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91520   int arg2 ;
91521   unsigned int *result = 0 ;
91522
91523   arg1 = (std::vector< unsigned int > *)jarg1;
91524   arg2 = (int)jarg2;
91525   {
91526     try {
91527       try {
91528         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
91529       }
91530       catch(std::out_of_range &_e) {
91531         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91532         return 0;
91533       }
91534
91535     } catch (std::out_of_range& e) {
91536       {
91537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91538       };
91539     } catch (std::exception& e) {
91540       {
91541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91542       };
91543     } catch (Dali::DaliException e) {
91544       {
91545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91546       };
91547     } catch (...) {
91548       {
91549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91550       };
91551     }
91552   }
91553
91554   jresult = *result;
91555   return jresult;
91556 }
91557
91558
91559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
91560   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91561   int arg2 ;
91562   unsigned int *arg3 = 0 ;
91563   unsigned int temp3 ;
91564
91565   arg1 = (std::vector< unsigned int > *)jarg1;
91566   arg2 = (int)jarg2;
91567   temp3 = (unsigned int)jarg3;
91568   arg3 = &temp3;
91569   {
91570     try {
91571       try {
91572         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
91573       }
91574       catch(std::out_of_range &_e) {
91575         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91576         return ;
91577       }
91578
91579     } catch (std::out_of_range& e) {
91580       {
91581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91582       };
91583     } catch (std::exception& e) {
91584       {
91585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91586       };
91587     } catch (Dali::DaliException e) {
91588       {
91589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91590       };
91591     } catch (...) {
91592       {
91593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91594       };
91595     }
91596   }
91597
91598 }
91599
91600
91601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
91602   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91603   std::vector< unsigned int > *arg2 = 0 ;
91604
91605   arg1 = (std::vector< unsigned int > *)jarg1;
91606   arg2 = (std::vector< unsigned int > *)jarg2;
91607   if (!arg2) {
91608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91609     return ;
91610   }
91611   {
91612     try {
91613       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
91614     } catch (std::out_of_range& e) {
91615       {
91616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91617       };
91618     } catch (std::exception& e) {
91619       {
91620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91621       };
91622     } catch (Dali::DaliException e) {
91623       {
91624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91625       };
91626     } catch (...) {
91627       {
91628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91629       };
91630     }
91631   }
91632
91633 }
91634
91635
91636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
91637   void * jresult ;
91638   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91639   int arg2 ;
91640   int arg3 ;
91641   std::vector< unsigned int > *result = 0 ;
91642
91643   arg1 = (std::vector< unsigned int > *)jarg1;
91644   arg2 = (int)jarg2;
91645   arg3 = (int)jarg3;
91646   {
91647     try {
91648       try {
91649         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
91650       }
91651       catch(std::out_of_range &_e) {
91652         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91653         return 0;
91654       }
91655       catch(std::invalid_argument &_e) {
91656         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91657         return 0;
91658       }
91659
91660     } catch (std::out_of_range& e) {
91661       {
91662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91663       };
91664     } catch (std::exception& e) {
91665       {
91666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91667       };
91668     } catch (Dali::DaliException e) {
91669       {
91670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91671       };
91672     } catch (...) {
91673       {
91674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91675       };
91676     }
91677   }
91678
91679   jresult = (void *)result;
91680   return jresult;
91681 }
91682
91683
91684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
91685   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91686   int arg2 ;
91687   unsigned int *arg3 = 0 ;
91688   unsigned int temp3 ;
91689
91690   arg1 = (std::vector< unsigned int > *)jarg1;
91691   arg2 = (int)jarg2;
91692   temp3 = (unsigned int)jarg3;
91693   arg3 = &temp3;
91694   {
91695     try {
91696       try {
91697         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
91698       }
91699       catch(std::out_of_range &_e) {
91700         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91701         return ;
91702       }
91703
91704     } catch (std::out_of_range& e) {
91705       {
91706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91707       };
91708     } catch (std::exception& e) {
91709       {
91710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91711       };
91712     } catch (Dali::DaliException e) {
91713       {
91714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91715       };
91716     } catch (...) {
91717       {
91718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91719       };
91720     }
91721   }
91722
91723 }
91724
91725
91726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
91727   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91728   int arg2 ;
91729   std::vector< unsigned int > *arg3 = 0 ;
91730
91731   arg1 = (std::vector< unsigned int > *)jarg1;
91732   arg2 = (int)jarg2;
91733   arg3 = (std::vector< unsigned int > *)jarg3;
91734   if (!arg3) {
91735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91736     return ;
91737   }
91738   {
91739     try {
91740       try {
91741         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
91742       }
91743       catch(std::out_of_range &_e) {
91744         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91745         return ;
91746       }
91747
91748     } catch (std::out_of_range& e) {
91749       {
91750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91751       };
91752     } catch (std::exception& e) {
91753       {
91754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91755       };
91756     } catch (Dali::DaliException e) {
91757       {
91758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91759       };
91760     } catch (...) {
91761       {
91762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91763       };
91764     }
91765   }
91766
91767 }
91768
91769
91770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
91771   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91772   int arg2 ;
91773
91774   arg1 = (std::vector< unsigned int > *)jarg1;
91775   arg2 = (int)jarg2;
91776   {
91777     try {
91778       try {
91779         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
91780       }
91781       catch(std::out_of_range &_e) {
91782         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91783         return ;
91784       }
91785
91786     } catch (std::out_of_range& e) {
91787       {
91788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91789       };
91790     } catch (std::exception& e) {
91791       {
91792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91793       };
91794     } catch (Dali::DaliException e) {
91795       {
91796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91797       };
91798     } catch (...) {
91799       {
91800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91801       };
91802     }
91803   }
91804
91805 }
91806
91807
91808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
91809   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91810   int arg2 ;
91811   int arg3 ;
91812
91813   arg1 = (std::vector< unsigned int > *)jarg1;
91814   arg2 = (int)jarg2;
91815   arg3 = (int)jarg3;
91816   {
91817     try {
91818       try {
91819         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
91820       }
91821       catch(std::out_of_range &_e) {
91822         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91823         return ;
91824       }
91825       catch(std::invalid_argument &_e) {
91826         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91827         return ;
91828       }
91829
91830     } catch (std::out_of_range& e) {
91831       {
91832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91833       };
91834     } catch (std::exception& e) {
91835       {
91836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91837       };
91838     } catch (Dali::DaliException e) {
91839       {
91840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91841       };
91842     } catch (...) {
91843       {
91844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91845       };
91846     }
91847   }
91848
91849 }
91850
91851
91852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
91853   void * jresult ;
91854   unsigned int *arg1 = 0 ;
91855   int arg2 ;
91856   unsigned int temp1 ;
91857   std::vector< unsigned int > *result = 0 ;
91858
91859   temp1 = (unsigned int)jarg1;
91860   arg1 = &temp1;
91861   arg2 = (int)jarg2;
91862   {
91863     try {
91864       try {
91865         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
91866       }
91867       catch(std::out_of_range &_e) {
91868         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91869         return 0;
91870       }
91871
91872     } catch (std::out_of_range& e) {
91873       {
91874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91875       };
91876     } catch (std::exception& e) {
91877       {
91878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91879       };
91880     } catch (Dali::DaliException e) {
91881       {
91882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91883       };
91884     } catch (...) {
91885       {
91886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91887       };
91888     }
91889   }
91890
91891   jresult = (void *)result;
91892   return jresult;
91893 }
91894
91895
91896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
91897   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91898
91899   arg1 = (std::vector< unsigned int > *)jarg1;
91900   {
91901     try {
91902       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
91903     } catch (std::out_of_range& e) {
91904       {
91905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91906       };
91907     } catch (std::exception& e) {
91908       {
91909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91910       };
91911     } catch (Dali::DaliException e) {
91912       {
91913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91914       };
91915     } catch (...) {
91916       {
91917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91918       };
91919     }
91920   }
91921
91922 }
91923
91924
91925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
91926   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91927   int arg2 ;
91928   int arg3 ;
91929
91930   arg1 = (std::vector< unsigned int > *)jarg1;
91931   arg2 = (int)jarg2;
91932   arg3 = (int)jarg3;
91933   {
91934     try {
91935       try {
91936         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
91937       }
91938       catch(std::out_of_range &_e) {
91939         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91940         return ;
91941       }
91942       catch(std::invalid_argument &_e) {
91943         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91944         return ;
91945       }
91946
91947     } catch (std::out_of_range& e) {
91948       {
91949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91950       };
91951     } catch (std::exception& e) {
91952       {
91953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91954       };
91955     } catch (Dali::DaliException e) {
91956       {
91957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91958       };
91959     } catch (...) {
91960       {
91961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91962       };
91963     }
91964   }
91965
91966 }
91967
91968
91969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
91970   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91971   int arg2 ;
91972   std::vector< unsigned int > *arg3 = 0 ;
91973
91974   arg1 = (std::vector< unsigned int > *)jarg1;
91975   arg2 = (int)jarg2;
91976   arg3 = (std::vector< unsigned int > *)jarg3;
91977   if (!arg3) {
91978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91979     return ;
91980   }
91981   {
91982     try {
91983       try {
91984         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
91985       }
91986       catch(std::out_of_range &_e) {
91987         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91988         return ;
91989       }
91990
91991     } catch (std::out_of_range& e) {
91992       {
91993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91994       };
91995     } catch (std::exception& e) {
91996       {
91997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91998       };
91999     } catch (Dali::DaliException e) {
92000       {
92001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92002       };
92003     } catch (...) {
92004       {
92005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92006       };
92007     }
92008   }
92009
92010 }
92011
92012
92013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
92014   unsigned int jresult ;
92015   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92016   unsigned int *arg2 = 0 ;
92017   unsigned int temp2 ;
92018   bool result;
92019
92020   arg1 = (std::vector< unsigned int > *)jarg1;
92021   temp2 = (unsigned int)jarg2;
92022   arg2 = &temp2;
92023   {
92024     try {
92025       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
92026     } catch (std::out_of_range& e) {
92027       {
92028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92029       };
92030     } catch (std::exception& e) {
92031       {
92032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92033       };
92034     } catch (Dali::DaliException e) {
92035       {
92036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92037       };
92038     } catch (...) {
92039       {
92040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92041       };
92042     }
92043   }
92044
92045   jresult = result;
92046   return jresult;
92047 }
92048
92049
92050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
92051   int jresult ;
92052   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92053   unsigned int *arg2 = 0 ;
92054   unsigned int temp2 ;
92055   int result;
92056
92057   arg1 = (std::vector< unsigned int > *)jarg1;
92058   temp2 = (unsigned int)jarg2;
92059   arg2 = &temp2;
92060   {
92061     try {
92062       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
92063     } catch (std::out_of_range& e) {
92064       {
92065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92066       };
92067     } catch (std::exception& e) {
92068       {
92069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92070       };
92071     } catch (Dali::DaliException e) {
92072       {
92073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92074       };
92075     } catch (...) {
92076       {
92077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92078       };
92079     }
92080   }
92081
92082   jresult = result;
92083   return jresult;
92084 }
92085
92086
92087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
92088   int jresult ;
92089   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92090   unsigned int *arg2 = 0 ;
92091   unsigned int temp2 ;
92092   int result;
92093
92094   arg1 = (std::vector< unsigned int > *)jarg1;
92095   temp2 = (unsigned int)jarg2;
92096   arg2 = &temp2;
92097   {
92098     try {
92099       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
92100     } catch (std::out_of_range& e) {
92101       {
92102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92103       };
92104     } catch (std::exception& e) {
92105       {
92106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92107       };
92108     } catch (Dali::DaliException e) {
92109       {
92110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92111       };
92112     } catch (...) {
92113       {
92114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92115       };
92116     }
92117   }
92118
92119   jresult = result;
92120   return jresult;
92121 }
92122
92123
92124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
92125   unsigned int jresult ;
92126   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92127   unsigned int *arg2 = 0 ;
92128   unsigned int temp2 ;
92129   bool result;
92130
92131   arg1 = (std::vector< unsigned int > *)jarg1;
92132   temp2 = (unsigned int)jarg2;
92133   arg2 = &temp2;
92134   {
92135     try {
92136       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
92137     } catch (std::out_of_range& e) {
92138       {
92139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92140       };
92141     } catch (std::exception& e) {
92142       {
92143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92144       };
92145     } catch (Dali::DaliException e) {
92146       {
92147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92148       };
92149     } catch (...) {
92150       {
92151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92152       };
92153     }
92154   }
92155
92156   jresult = result;
92157   return jresult;
92158 }
92159
92160
92161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
92162   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92163
92164   arg1 = (std::vector< unsigned int > *)jarg1;
92165   {
92166     try {
92167       delete arg1;
92168     } catch (std::out_of_range& e) {
92169       {
92170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92171       };
92172     } catch (std::exception& e) {
92173       {
92174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92175       };
92176     } catch (Dali::DaliException e) {
92177       {
92178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92179       };
92180     } catch (...) {
92181       {
92182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92183       };
92184     }
92185   }
92186
92187 }
92188
92189
92190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
92191   void * jresult ;
92192   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92193
92194   {
92195     try {
92196       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
92197     } catch (std::out_of_range& e) {
92198       {
92199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92200       };
92201     } catch (std::exception& e) {
92202       {
92203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92204       };
92205     } catch (Dali::DaliException e) {
92206       {
92207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92208       };
92209     } catch (...) {
92210       {
92211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92212       };
92213     }
92214   }
92215
92216   jresult = (void *)result;
92217   return jresult;
92218 }
92219
92220
92221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
92222   void * jresult ;
92223   unsigned int arg1 ;
92224   Dali::Actor arg2 ;
92225   Dali::Actor *argp2 ;
92226   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92227
92228   arg1 = (unsigned int)jarg1;
92229   argp2 = (Dali::Actor *)jarg2;
92230   if (!argp2) {
92231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92232     return 0;
92233   }
92234   arg2 = *argp2;
92235   {
92236     try {
92237       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
92238     } catch (std::out_of_range& e) {
92239       {
92240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92241       };
92242     } catch (std::exception& e) {
92243       {
92244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92245       };
92246     } catch (Dali::DaliException e) {
92247       {
92248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92249       };
92250     } catch (...) {
92251       {
92252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92253       };
92254     }
92255   }
92256
92257   jresult = (void *)result;
92258   return jresult;
92259 }
92260
92261
92262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
92263   void * jresult ;
92264   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
92265   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92266
92267   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92268   if (!arg1) {
92269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92270     return 0;
92271   }
92272   {
92273     try {
92274       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
92275     } catch (std::out_of_range& e) {
92276       {
92277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92278       };
92279     } catch (std::exception& e) {
92280       {
92281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92282       };
92283     } catch (Dali::DaliException e) {
92284       {
92285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92286       };
92287     } catch (...) {
92288       {
92289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92290       };
92291     }
92292   }
92293
92294   jresult = (void *)result;
92295   return jresult;
92296 }
92297
92298
92299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
92300   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92301   unsigned int arg2 ;
92302
92303   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92304   arg2 = (unsigned int)jarg2;
92305   if (arg1) (arg1)->first = arg2;
92306 }
92307
92308
92309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
92310   unsigned int jresult ;
92311   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92312   unsigned int result;
92313
92314   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92315   result = (unsigned int) ((arg1)->first);
92316   jresult = result;
92317   return jresult;
92318 }
92319
92320
92321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
92322   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92323   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
92324
92325   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92326   arg2 = (Dali::Actor *)jarg2;
92327   if (arg1) (arg1)->second = *arg2;
92328 }
92329
92330
92331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
92332   void * jresult ;
92333   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92334   Dali::Actor *result = 0 ;
92335
92336   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92337   result = (Dali::Actor *)& ((arg1)->second);
92338   jresult = (void *)result;
92339   return jresult;
92340 }
92341
92342
92343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
92344   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92345
92346   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92347   {
92348     try {
92349       delete arg1;
92350     } catch (std::out_of_range& e) {
92351       {
92352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92353       };
92354     } catch (std::exception& e) {
92355       {
92356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92357       };
92358     } catch (Dali::DaliException e) {
92359       {
92360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92361       };
92362     } catch (...) {
92363       {
92364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92365       };
92366     }
92367   }
92368
92369 }
92370
92371
92372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
92373   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92374
92375   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92376   {
92377     try {
92378       (arg1)->clear();
92379     } catch (std::out_of_range& e) {
92380       {
92381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92382       };
92383     } catch (std::exception& e) {
92384       {
92385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92386       };
92387     } catch (Dali::DaliException e) {
92388       {
92389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92390       };
92391     } catch (...) {
92392       {
92393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92394       };
92395     }
92396   }
92397
92398 }
92399
92400
92401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
92402   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92403   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
92404
92405   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92406   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
92407   if (!arg2) {
92408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92409     return ;
92410   }
92411   {
92412     try {
92413       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
92414     } catch (std::out_of_range& e) {
92415       {
92416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92417       };
92418     } catch (std::exception& e) {
92419       {
92420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92421       };
92422     } catch (Dali::DaliException e) {
92423       {
92424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92425       };
92426     } catch (...) {
92427       {
92428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92429       };
92430     }
92431   }
92432
92433 }
92434
92435
92436 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
92437   unsigned long jresult ;
92438   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92439   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92440
92441   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92442   {
92443     try {
92444       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
92445     } catch (std::out_of_range& e) {
92446       {
92447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92448       };
92449     } catch (std::exception& e) {
92450       {
92451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92452       };
92453     } catch (Dali::DaliException e) {
92454       {
92455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92456       };
92457     } catch (...) {
92458       {
92459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92460       };
92461     }
92462   }
92463
92464   jresult = (unsigned long)result;
92465   return jresult;
92466 }
92467
92468
92469 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
92470   unsigned long jresult ;
92471   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92472   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92473
92474   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92475   {
92476     try {
92477       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
92478     } catch (std::out_of_range& e) {
92479       {
92480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92481       };
92482     } catch (std::exception& e) {
92483       {
92484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92485       };
92486     } catch (Dali::DaliException e) {
92487       {
92488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92489       };
92490     } catch (...) {
92491       {
92492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92493       };
92494     }
92495   }
92496
92497   jresult = (unsigned long)result;
92498   return jresult;
92499 }
92500
92501
92502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
92503   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92504   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
92505
92506   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92507   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
92508   {
92509     try {
92510       (arg1)->reserve(arg2);
92511     } catch (std::out_of_range& e) {
92512       {
92513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92514       };
92515     } catch (std::exception& e) {
92516       {
92517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92518       };
92519     } catch (Dali::DaliException e) {
92520       {
92521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92522       };
92523     } catch (...) {
92524       {
92525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92526       };
92527     }
92528   }
92529
92530 }
92531
92532
92533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
92534   void * jresult ;
92535   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92536
92537   {
92538     try {
92539       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
92540     } catch (std::out_of_range& e) {
92541       {
92542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92543       };
92544     } catch (std::exception& e) {
92545       {
92546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92547       };
92548     } catch (Dali::DaliException e) {
92549       {
92550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92551       };
92552     } catch (...) {
92553       {
92554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92555       };
92556     }
92557   }
92558
92559   jresult = (void *)result;
92560   return jresult;
92561 }
92562
92563
92564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
92565   void * jresult ;
92566   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
92567   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92568
92569   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92570   if (!arg1) {
92571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92572     return 0;
92573   }
92574   {
92575     try {
92576       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);
92577     } catch (std::out_of_range& e) {
92578       {
92579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92580       };
92581     } catch (std::exception& e) {
92582       {
92583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92584       };
92585     } catch (Dali::DaliException e) {
92586       {
92587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92588       };
92589     } catch (...) {
92590       {
92591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92592       };
92593     }
92594   }
92595
92596   jresult = (void *)result;
92597   return jresult;
92598 }
92599
92600
92601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
92602   void * jresult ;
92603   int arg1 ;
92604   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92605
92606   arg1 = (int)jarg1;
92607   {
92608     try {
92609       try {
92610         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);
92611       }
92612       catch(std::out_of_range &_e) {
92613         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92614         return 0;
92615       }
92616
92617     } catch (std::out_of_range& e) {
92618       {
92619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92620       };
92621     } catch (std::exception& e) {
92622       {
92623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92624       };
92625     } catch (Dali::DaliException e) {
92626       {
92627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92628       };
92629     } catch (...) {
92630       {
92631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92632       };
92633     }
92634   }
92635
92636   jresult = (void *)result;
92637   return jresult;
92638 }
92639
92640
92641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
92642   void * jresult ;
92643   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92644   int arg2 ;
92645   std::pair< unsigned int,Dali::Actor > result;
92646
92647   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92648   arg2 = (int)jarg2;
92649   {
92650     try {
92651       try {
92652         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
92653       }
92654       catch(std::out_of_range &_e) {
92655         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92656         return 0;
92657       }
92658
92659     } catch (std::out_of_range& e) {
92660       {
92661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92662       };
92663     } catch (std::exception& e) {
92664       {
92665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92666       };
92667     } catch (Dali::DaliException e) {
92668       {
92669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92670       };
92671     } catch (...) {
92672       {
92673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92674       };
92675     }
92676   }
92677
92678   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
92679   return jresult;
92680 }
92681
92682
92683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
92684   void * jresult ;
92685   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92686   int arg2 ;
92687   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92688
92689   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92690   arg2 = (int)jarg2;
92691   {
92692     try {
92693       try {
92694         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
92695       }
92696       catch(std::out_of_range &_e) {
92697         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92698         return 0;
92699       }
92700
92701     } catch (std::out_of_range& e) {
92702       {
92703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92704       };
92705     } catch (std::exception& e) {
92706       {
92707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92708       };
92709     } catch (Dali::DaliException e) {
92710       {
92711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92712       };
92713     } catch (...) {
92714       {
92715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92716       };
92717     }
92718   }
92719
92720   jresult = (void *)result;
92721   return jresult;
92722 }
92723
92724
92725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
92726   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92727   int arg2 ;
92728   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
92729
92730   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92731   arg2 = (int)jarg2;
92732   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
92733   if (!arg3) {
92734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92735     return ;
92736   }
92737   {
92738     try {
92739       try {
92740         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);
92741       }
92742       catch(std::out_of_range &_e) {
92743         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92744         return ;
92745       }
92746
92747     } catch (std::out_of_range& e) {
92748       {
92749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92750       };
92751     } catch (std::exception& e) {
92752       {
92753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92754       };
92755     } catch (Dali::DaliException e) {
92756       {
92757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92758       };
92759     } catch (...) {
92760       {
92761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92762       };
92763     }
92764   }
92765
92766 }
92767
92768
92769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
92770   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92771   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
92772
92773   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92774   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
92775   if (!arg2) {
92776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92777     return ;
92778   }
92779   {
92780     try {
92781       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);
92782     } catch (std::out_of_range& e) {
92783       {
92784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92785       };
92786     } catch (std::exception& e) {
92787       {
92788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92789       };
92790     } catch (Dali::DaliException e) {
92791       {
92792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92793       };
92794     } catch (...) {
92795       {
92796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92797       };
92798     }
92799   }
92800
92801 }
92802
92803
92804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92805   void * jresult ;
92806   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92807   int arg2 ;
92808   int arg3 ;
92809   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92810
92811   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92812   arg2 = (int)jarg2;
92813   arg3 = (int)jarg3;
92814   {
92815     try {
92816       try {
92817         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);
92818       }
92819       catch(std::out_of_range &_e) {
92820         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92821         return 0;
92822       }
92823       catch(std::invalid_argument &_e) {
92824         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92825         return 0;
92826       }
92827
92828     } catch (std::out_of_range& e) {
92829       {
92830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92831       };
92832     } catch (std::exception& e) {
92833       {
92834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92835       };
92836     } catch (Dali::DaliException e) {
92837       {
92838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92839       };
92840     } catch (...) {
92841       {
92842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92843       };
92844     }
92845   }
92846
92847   jresult = (void *)result;
92848   return jresult;
92849 }
92850
92851
92852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
92853   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92854   int arg2 ;
92855   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
92856
92857   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92858   arg2 = (int)jarg2;
92859   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
92860   if (!arg3) {
92861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92862     return ;
92863   }
92864   {
92865     try {
92866       try {
92867         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);
92868       }
92869       catch(std::out_of_range &_e) {
92870         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92871         return ;
92872       }
92873
92874     } catch (std::out_of_range& e) {
92875       {
92876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92877       };
92878     } catch (std::exception& e) {
92879       {
92880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92881       };
92882     } catch (Dali::DaliException e) {
92883       {
92884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92885       };
92886     } catch (...) {
92887       {
92888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92889       };
92890     }
92891   }
92892
92893 }
92894
92895
92896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
92897   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92898   int arg2 ;
92899   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
92900
92901   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92902   arg2 = (int)jarg2;
92903   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
92904   if (!arg3) {
92905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92906     return ;
92907   }
92908   {
92909     try {
92910       try {
92911         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);
92912       }
92913       catch(std::out_of_range &_e) {
92914         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92915         return ;
92916       }
92917
92918     } catch (std::out_of_range& e) {
92919       {
92920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92921       };
92922     } catch (std::exception& e) {
92923       {
92924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92925       };
92926     } catch (Dali::DaliException e) {
92927       {
92928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92929       };
92930     } catch (...) {
92931       {
92932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92933       };
92934     }
92935   }
92936
92937 }
92938
92939
92940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
92941   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92942   int arg2 ;
92943
92944   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92945   arg2 = (int)jarg2;
92946   {
92947     try {
92948       try {
92949         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
92950       }
92951       catch(std::out_of_range &_e) {
92952         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92953         return ;
92954       }
92955
92956     } catch (std::out_of_range& e) {
92957       {
92958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92959       };
92960     } catch (std::exception& e) {
92961       {
92962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92963       };
92964     } catch (Dali::DaliException e) {
92965       {
92966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92967       };
92968     } catch (...) {
92969       {
92970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92971       };
92972     }
92973   }
92974
92975 }
92976
92977
92978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
92979   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92980   int arg2 ;
92981   int arg3 ;
92982
92983   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92984   arg2 = (int)jarg2;
92985   arg3 = (int)jarg3;
92986   {
92987     try {
92988       try {
92989         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
92990       }
92991       catch(std::out_of_range &_e) {
92992         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92993         return ;
92994       }
92995       catch(std::invalid_argument &_e) {
92996         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92997         return ;
92998       }
92999
93000     } catch (std::out_of_range& e) {
93001       {
93002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93003       };
93004     } catch (std::exception& e) {
93005       {
93006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93007       };
93008     } catch (Dali::DaliException e) {
93009       {
93010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93011       };
93012     } catch (...) {
93013       {
93014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93015       };
93016     }
93017   }
93018
93019 }
93020
93021
93022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
93023   void * jresult ;
93024   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93025   int arg2 ;
93026   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93027
93028   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93029   if (!arg1) {
93030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93031     return 0;
93032   }
93033   arg2 = (int)jarg2;
93034   {
93035     try {
93036       try {
93037         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);
93038       }
93039       catch(std::out_of_range &_e) {
93040         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93041         return 0;
93042       }
93043
93044     } catch (std::out_of_range& e) {
93045       {
93046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93047       };
93048     } catch (std::exception& e) {
93049       {
93050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93051       };
93052     } catch (Dali::DaliException e) {
93053       {
93054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93055       };
93056     } catch (...) {
93057       {
93058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93059       };
93060     }
93061   }
93062
93063   jresult = (void *)result;
93064   return jresult;
93065 }
93066
93067
93068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
93069   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93070
93071   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93072   {
93073     try {
93074       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
93075     } catch (std::out_of_range& e) {
93076       {
93077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93078       };
93079     } catch (std::exception& e) {
93080       {
93081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93082       };
93083     } catch (Dali::DaliException e) {
93084       {
93085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93086       };
93087     } catch (...) {
93088       {
93089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93090       };
93091     }
93092   }
93093
93094 }
93095
93096
93097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93098   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93099   int arg2 ;
93100   int arg3 ;
93101
93102   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93103   arg2 = (int)jarg2;
93104   arg3 = (int)jarg3;
93105   {
93106     try {
93107       try {
93108         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93109       }
93110       catch(std::out_of_range &_e) {
93111         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93112         return ;
93113       }
93114       catch(std::invalid_argument &_e) {
93115         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93116         return ;
93117       }
93118
93119     } catch (std::out_of_range& e) {
93120       {
93121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93122       };
93123     } catch (std::exception& e) {
93124       {
93125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93126       };
93127     } catch (Dali::DaliException e) {
93128       {
93129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93130       };
93131     } catch (...) {
93132       {
93133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93134       };
93135     }
93136   }
93137
93138 }
93139
93140
93141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93142   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93143   int arg2 ;
93144   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93145
93146   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93147   arg2 = (int)jarg2;
93148   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93149   if (!arg3) {
93150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93151     return ;
93152   }
93153   {
93154     try {
93155       try {
93156         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);
93157       }
93158       catch(std::out_of_range &_e) {
93159         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93160         return ;
93161       }
93162
93163     } catch (std::out_of_range& e) {
93164       {
93165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93166       };
93167     } catch (std::exception& e) {
93168       {
93169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93170       };
93171     } catch (Dali::DaliException e) {
93172       {
93173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93174       };
93175     } catch (...) {
93176       {
93177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93178       };
93179     }
93180   }
93181
93182 }
93183
93184
93185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
93186   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93187
93188   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93189   {
93190     try {
93191       delete arg1;
93192     } catch (std::out_of_range& e) {
93193       {
93194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93195       };
93196     } catch (std::exception& e) {
93197       {
93198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93199       };
93200     } catch (Dali::DaliException e) {
93201       {
93202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93203       };
93204     } catch (...) {
93205       {
93206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93207       };
93208     }
93209   }
93210
93211 }
93212
93213
93214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
93215   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93216
93217   arg1 = (std::vector< Dali::Actor > *)jarg1;
93218   {
93219     try {
93220       (arg1)->clear();
93221     } catch (std::out_of_range& e) {
93222       {
93223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93224       };
93225     } catch (std::exception& e) {
93226       {
93227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93228       };
93229     } catch (Dali::DaliException e) {
93230       {
93231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93232       };
93233     } catch (...) {
93234       {
93235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93236       };
93237     }
93238   }
93239
93240 }
93241
93242
93243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
93244   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93245   Dali::Actor *arg2 = 0 ;
93246
93247   arg1 = (std::vector< Dali::Actor > *)jarg1;
93248   arg2 = (Dali::Actor *)jarg2;
93249   if (!arg2) {
93250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93251     return ;
93252   }
93253   {
93254     try {
93255       (arg1)->push_back((Dali::Actor const &)*arg2);
93256     } catch (std::out_of_range& e) {
93257       {
93258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93259       };
93260     } catch (std::exception& e) {
93261       {
93262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93263       };
93264     } catch (Dali::DaliException e) {
93265       {
93266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93267       };
93268     } catch (...) {
93269       {
93270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93271       };
93272     }
93273   }
93274
93275 }
93276
93277
93278 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
93279   unsigned long jresult ;
93280   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93281   std::vector< Dali::Actor >::size_type result;
93282
93283   arg1 = (std::vector< Dali::Actor > *)jarg1;
93284   {
93285     try {
93286       result = ((std::vector< Dali::Actor > const *)arg1)->size();
93287     } catch (std::out_of_range& e) {
93288       {
93289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93290       };
93291     } catch (std::exception& e) {
93292       {
93293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93294       };
93295     } catch (Dali::DaliException e) {
93296       {
93297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93298       };
93299     } catch (...) {
93300       {
93301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93302       };
93303     }
93304   }
93305
93306   jresult = (unsigned long)result;
93307   return jresult;
93308 }
93309
93310
93311 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
93312   unsigned long jresult ;
93313   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93314   std::vector< Dali::Actor >::size_type result;
93315
93316   arg1 = (std::vector< Dali::Actor > *)jarg1;
93317   {
93318     try {
93319       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
93320     } catch (std::out_of_range& e) {
93321       {
93322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93323       };
93324     } catch (std::exception& e) {
93325       {
93326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93327       };
93328     } catch (Dali::DaliException e) {
93329       {
93330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93331       };
93332     } catch (...) {
93333       {
93334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93335       };
93336     }
93337   }
93338
93339   jresult = (unsigned long)result;
93340   return jresult;
93341 }
93342
93343
93344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
93345   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93346   std::vector< Dali::Actor >::size_type arg2 ;
93347
93348   arg1 = (std::vector< Dali::Actor > *)jarg1;
93349   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
93350   {
93351     try {
93352       (arg1)->reserve(arg2);
93353     } catch (std::out_of_range& e) {
93354       {
93355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93356       };
93357     } catch (std::exception& e) {
93358       {
93359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93360       };
93361     } catch (Dali::DaliException e) {
93362       {
93363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93364       };
93365     } catch (...) {
93366       {
93367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93368       };
93369     }
93370   }
93371
93372 }
93373
93374
93375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
93376   void * jresult ;
93377   std::vector< Dali::Actor > *result = 0 ;
93378
93379   {
93380     try {
93381       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
93382     } catch (std::out_of_range& e) {
93383       {
93384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93385       };
93386     } catch (std::exception& e) {
93387       {
93388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93389       };
93390     } catch (Dali::DaliException e) {
93391       {
93392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93393       };
93394     } catch (...) {
93395       {
93396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93397       };
93398     }
93399   }
93400
93401   jresult = (void *)result;
93402   return jresult;
93403 }
93404
93405
93406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
93407   void * jresult ;
93408   std::vector< Dali::Actor > *arg1 = 0 ;
93409   std::vector< Dali::Actor > *result = 0 ;
93410
93411   arg1 = (std::vector< Dali::Actor > *)jarg1;
93412   if (!arg1) {
93413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93414     return 0;
93415   }
93416   {
93417     try {
93418       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
93419     } catch (std::out_of_range& e) {
93420       {
93421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93422       };
93423     } catch (std::exception& e) {
93424       {
93425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93426       };
93427     } catch (Dali::DaliException e) {
93428       {
93429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93430       };
93431     } catch (...) {
93432       {
93433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93434       };
93435     }
93436   }
93437
93438   jresult = (void *)result;
93439   return jresult;
93440 }
93441
93442
93443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
93444   void * jresult ;
93445   int arg1 ;
93446   std::vector< Dali::Actor > *result = 0 ;
93447
93448   arg1 = (int)jarg1;
93449   {
93450     try {
93451       try {
93452         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
93453       }
93454       catch(std::out_of_range &_e) {
93455         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93456         return 0;
93457       }
93458
93459     } catch (std::out_of_range& e) {
93460       {
93461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93462       };
93463     } catch (std::exception& e) {
93464       {
93465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93466       };
93467     } catch (Dali::DaliException e) {
93468       {
93469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93470       };
93471     } catch (...) {
93472       {
93473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93474       };
93475     }
93476   }
93477
93478   jresult = (void *)result;
93479   return jresult;
93480 }
93481
93482
93483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
93484   void * jresult ;
93485   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93486   int arg2 ;
93487   Dali::Actor result;
93488
93489   arg1 = (std::vector< Dali::Actor > *)jarg1;
93490   arg2 = (int)jarg2;
93491   {
93492     try {
93493       try {
93494         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
93495       }
93496       catch(std::out_of_range &_e) {
93497         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93498         return 0;
93499       }
93500
93501     } catch (std::out_of_range& e) {
93502       {
93503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93504       };
93505     } catch (std::exception& e) {
93506       {
93507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93508       };
93509     } catch (Dali::DaliException e) {
93510       {
93511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93512       };
93513     } catch (...) {
93514       {
93515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93516       };
93517     }
93518   }
93519
93520   jresult = new Dali::Actor((const Dali::Actor &)result);
93521   return jresult;
93522 }
93523
93524
93525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
93526   void * jresult ;
93527   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93528   int arg2 ;
93529   Dali::Actor *result = 0 ;
93530
93531   arg1 = (std::vector< Dali::Actor > *)jarg1;
93532   arg2 = (int)jarg2;
93533   {
93534     try {
93535       try {
93536         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
93537       }
93538       catch(std::out_of_range &_e) {
93539         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93540         return 0;
93541       }
93542
93543     } catch (std::out_of_range& e) {
93544       {
93545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93546       };
93547     } catch (std::exception& e) {
93548       {
93549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93550       };
93551     } catch (Dali::DaliException e) {
93552       {
93553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93554       };
93555     } catch (...) {
93556       {
93557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93558       };
93559     }
93560   }
93561
93562   jresult = (void *)result;
93563   return jresult;
93564 }
93565
93566
93567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93568   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93569   int arg2 ;
93570   Dali::Actor *arg3 = 0 ;
93571
93572   arg1 = (std::vector< Dali::Actor > *)jarg1;
93573   arg2 = (int)jarg2;
93574   arg3 = (Dali::Actor *)jarg3;
93575   if (!arg3) {
93576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93577     return ;
93578   }
93579   {
93580     try {
93581       try {
93582         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
93583       }
93584       catch(std::out_of_range &_e) {
93585         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93586         return ;
93587       }
93588
93589     } catch (std::out_of_range& e) {
93590       {
93591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93592       };
93593     } catch (std::exception& e) {
93594       {
93595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93596       };
93597     } catch (Dali::DaliException e) {
93598       {
93599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93600       };
93601     } catch (...) {
93602       {
93603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93604       };
93605     }
93606   }
93607
93608 }
93609
93610
93611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
93612   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93613   std::vector< Dali::Actor > *arg2 = 0 ;
93614
93615   arg1 = (std::vector< Dali::Actor > *)jarg1;
93616   arg2 = (std::vector< Dali::Actor > *)jarg2;
93617   if (!arg2) {
93618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93619     return ;
93620   }
93621   {
93622     try {
93623       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
93624     } catch (std::out_of_range& e) {
93625       {
93626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93627       };
93628     } catch (std::exception& e) {
93629       {
93630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93631       };
93632     } catch (Dali::DaliException e) {
93633       {
93634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93635       };
93636     } catch (...) {
93637       {
93638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93639       };
93640     }
93641   }
93642
93643 }
93644
93645
93646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93647   void * jresult ;
93648   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93649   int arg2 ;
93650   int arg3 ;
93651   std::vector< Dali::Actor > *result = 0 ;
93652
93653   arg1 = (std::vector< Dali::Actor > *)jarg1;
93654   arg2 = (int)jarg2;
93655   arg3 = (int)jarg3;
93656   {
93657     try {
93658       try {
93659         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
93660       }
93661       catch(std::out_of_range &_e) {
93662         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93663         return 0;
93664       }
93665       catch(std::invalid_argument &_e) {
93666         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93667         return 0;
93668       }
93669
93670     } catch (std::out_of_range& e) {
93671       {
93672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93673       };
93674     } catch (std::exception& e) {
93675       {
93676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93677       };
93678     } catch (Dali::DaliException e) {
93679       {
93680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93681       };
93682     } catch (...) {
93683       {
93684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93685       };
93686     }
93687   }
93688
93689   jresult = (void *)result;
93690   return jresult;
93691 }
93692
93693
93694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93695   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93696   int arg2 ;
93697   Dali::Actor *arg3 = 0 ;
93698
93699   arg1 = (std::vector< Dali::Actor > *)jarg1;
93700   arg2 = (int)jarg2;
93701   arg3 = (Dali::Actor *)jarg3;
93702   if (!arg3) {
93703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93704     return ;
93705   }
93706   {
93707     try {
93708       try {
93709         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
93710       }
93711       catch(std::out_of_range &_e) {
93712         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93713         return ;
93714       }
93715
93716     } catch (std::out_of_range& e) {
93717       {
93718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93719       };
93720     } catch (std::exception& e) {
93721       {
93722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93723       };
93724     } catch (Dali::DaliException e) {
93725       {
93726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93727       };
93728     } catch (...) {
93729       {
93730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93731       };
93732     }
93733   }
93734
93735 }
93736
93737
93738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93739   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93740   int arg2 ;
93741   std::vector< Dali::Actor > *arg3 = 0 ;
93742
93743   arg1 = (std::vector< Dali::Actor > *)jarg1;
93744   arg2 = (int)jarg2;
93745   arg3 = (std::vector< Dali::Actor > *)jarg3;
93746   if (!arg3) {
93747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93748     return ;
93749   }
93750   {
93751     try {
93752       try {
93753         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
93754       }
93755       catch(std::out_of_range &_e) {
93756         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93757         return ;
93758       }
93759
93760     } catch (std::out_of_range& e) {
93761       {
93762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93763       };
93764     } catch (std::exception& e) {
93765       {
93766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93767       };
93768     } catch (Dali::DaliException e) {
93769       {
93770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93771       };
93772     } catch (...) {
93773       {
93774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93775       };
93776     }
93777   }
93778
93779 }
93780
93781
93782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
93783   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93784   int arg2 ;
93785
93786   arg1 = (std::vector< Dali::Actor > *)jarg1;
93787   arg2 = (int)jarg2;
93788   {
93789     try {
93790       try {
93791         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
93792       }
93793       catch(std::out_of_range &_e) {
93794         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93795         return ;
93796       }
93797
93798     } catch (std::out_of_range& e) {
93799       {
93800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93801       };
93802     } catch (std::exception& e) {
93803       {
93804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93805       };
93806     } catch (Dali::DaliException e) {
93807       {
93808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93809       };
93810     } catch (...) {
93811       {
93812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93813       };
93814     }
93815   }
93816
93817 }
93818
93819
93820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93821   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93822   int arg2 ;
93823   int arg3 ;
93824
93825   arg1 = (std::vector< Dali::Actor > *)jarg1;
93826   arg2 = (int)jarg2;
93827   arg3 = (int)jarg3;
93828   {
93829     try {
93830       try {
93831         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
93832       }
93833       catch(std::out_of_range &_e) {
93834         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93835         return ;
93836       }
93837       catch(std::invalid_argument &_e) {
93838         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93839         return ;
93840       }
93841
93842     } catch (std::out_of_range& e) {
93843       {
93844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93845       };
93846     } catch (std::exception& e) {
93847       {
93848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93849       };
93850     } catch (Dali::DaliException e) {
93851       {
93852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93853       };
93854     } catch (...) {
93855       {
93856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93857       };
93858     }
93859   }
93860
93861 }
93862
93863
93864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
93865   void * jresult ;
93866   Dali::Actor *arg1 = 0 ;
93867   int arg2 ;
93868   std::vector< Dali::Actor > *result = 0 ;
93869
93870   arg1 = (Dali::Actor *)jarg1;
93871   if (!arg1) {
93872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93873     return 0;
93874   }
93875   arg2 = (int)jarg2;
93876   {
93877     try {
93878       try {
93879         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
93880       }
93881       catch(std::out_of_range &_e) {
93882         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93883         return 0;
93884       }
93885
93886     } catch (std::out_of_range& e) {
93887       {
93888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93889       };
93890     } catch (std::exception& e) {
93891       {
93892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93893       };
93894     } catch (Dali::DaliException e) {
93895       {
93896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93897       };
93898     } catch (...) {
93899       {
93900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93901       };
93902     }
93903   }
93904
93905   jresult = (void *)result;
93906   return jresult;
93907 }
93908
93909
93910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
93911   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93912
93913   arg1 = (std::vector< Dali::Actor > *)jarg1;
93914   {
93915     try {
93916       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
93917     } catch (std::out_of_range& e) {
93918       {
93919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93920       };
93921     } catch (std::exception& e) {
93922       {
93923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93924       };
93925     } catch (Dali::DaliException e) {
93926       {
93927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93928       };
93929     } catch (...) {
93930       {
93931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93932       };
93933     }
93934   }
93935
93936 }
93937
93938
93939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93940   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93941   int arg2 ;
93942   int arg3 ;
93943
93944   arg1 = (std::vector< Dali::Actor > *)jarg1;
93945   arg2 = (int)jarg2;
93946   arg3 = (int)jarg3;
93947   {
93948     try {
93949       try {
93950         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93951       }
93952       catch(std::out_of_range &_e) {
93953         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93954         return ;
93955       }
93956       catch(std::invalid_argument &_e) {
93957         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93958         return ;
93959       }
93960
93961     } catch (std::out_of_range& e) {
93962       {
93963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93964       };
93965     } catch (std::exception& e) {
93966       {
93967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93968       };
93969     } catch (Dali::DaliException e) {
93970       {
93971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93972       };
93973     } catch (...) {
93974       {
93975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93976       };
93977     }
93978   }
93979
93980 }
93981
93982
93983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93984   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93985   int arg2 ;
93986   std::vector< Dali::Actor > *arg3 = 0 ;
93987
93988   arg1 = (std::vector< Dali::Actor > *)jarg1;
93989   arg2 = (int)jarg2;
93990   arg3 = (std::vector< Dali::Actor > *)jarg3;
93991   if (!arg3) {
93992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93993     return ;
93994   }
93995   {
93996     try {
93997       try {
93998         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
93999       }
94000       catch(std::out_of_range &_e) {
94001         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94002         return ;
94003       }
94004
94005     } catch (std::out_of_range& e) {
94006       {
94007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94008       };
94009     } catch (std::exception& e) {
94010       {
94011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94012       };
94013     } catch (Dali::DaliException e) {
94014       {
94015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94016       };
94017     } catch (...) {
94018       {
94019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94020       };
94021     }
94022   }
94023
94024 }
94025
94026
94027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
94028   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94029
94030   arg1 = (std::vector< Dali::Actor > *)jarg1;
94031   {
94032     try {
94033       delete arg1;
94034     } catch (std::out_of_range& e) {
94035       {
94036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94037       };
94038     } catch (std::exception& e) {
94039       {
94040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94041       };
94042     } catch (Dali::DaliException e) {
94043       {
94044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94045       };
94046     } catch (...) {
94047       {
94048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94049       };
94050     }
94051   }
94052
94053 }
94054
94055
94056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
94057   unsigned int jresult ;
94058   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94059   bool result;
94060
94061   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94062   {
94063     try {
94064       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94065     } catch (std::out_of_range& e) {
94066       {
94067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94068       };
94069     } catch (std::exception& e) {
94070       {
94071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94072       };
94073     } catch (Dali::DaliException e) {
94074       {
94075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94076       };
94077     } catch (...) {
94078       {
94079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94080       };
94081     }
94082   }
94083
94084   jresult = result;
94085   return jresult;
94086 }
94087
94088
94089 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
94090   unsigned long jresult ;
94091   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94092   std::size_t result;
94093
94094   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94095   {
94096     try {
94097       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94098     } catch (std::out_of_range& e) {
94099       {
94100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94101       };
94102     } catch (std::exception& e) {
94103       {
94104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94105       };
94106     } catch (Dali::DaliException e) {
94107       {
94108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94109       };
94110     } catch (...) {
94111       {
94112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94113       };
94114     }
94115   }
94116
94117   jresult = (unsigned long)result;
94118   return jresult;
94119 }
94120
94121
94122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
94123   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94124   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94125
94126   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94127   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94128   {
94129     try {
94130       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
94131     } catch (std::out_of_range& e) {
94132       {
94133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94134       };
94135     } catch (std::exception& e) {
94136       {
94137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94138       };
94139     } catch (Dali::DaliException e) {
94140       {
94141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94142       };
94143     } catch (...) {
94144       {
94145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94146       };
94147     }
94148   }
94149
94150 }
94151
94152
94153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
94154   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94155   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94156
94157   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94158   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94159   {
94160     try {
94161       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
94162     } catch (std::out_of_range& e) {
94163       {
94164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94165       };
94166     } catch (std::exception& e) {
94167       {
94168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94169       };
94170     } catch (Dali::DaliException e) {
94171       {
94172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94173       };
94174     } catch (...) {
94175       {
94176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94177       };
94178     }
94179   }
94180
94181 }
94182
94183
94184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
94185   unsigned int jresult ;
94186   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94187   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
94188   bool result;
94189
94190   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94191   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
94192   if (!arg2) {
94193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
94194     return 0;
94195   }
94196   {
94197     try {
94198       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
94199     } catch (std::out_of_range& e) {
94200       {
94201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94202       };
94203     } catch (std::exception& e) {
94204       {
94205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94206       };
94207     } catch (Dali::DaliException e) {
94208       {
94209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94210       };
94211     } catch (...) {
94212       {
94213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94214       };
94215     }
94216   }
94217
94218   jresult = result;
94219   return jresult;
94220 }
94221
94222
94223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
94224   void * jresult ;
94225   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
94226
94227   {
94228     try {
94229       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
94230     } catch (std::out_of_range& e) {
94231       {
94232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94233       };
94234     } catch (std::exception& e) {
94235       {
94236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94237       };
94238     } catch (Dali::DaliException e) {
94239       {
94240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94241       };
94242     } catch (...) {
94243       {
94244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94245       };
94246     }
94247   }
94248
94249   jresult = (void *)result;
94250   return jresult;
94251 }
94252
94253
94254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
94255   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94256
94257   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94258   {
94259     try {
94260       delete arg1;
94261     } catch (std::out_of_range& e) {
94262       {
94263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94264       };
94265     } catch (std::exception& e) {
94266       {
94267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94268       };
94269     } catch (Dali::DaliException e) {
94270       {
94271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94272       };
94273     } catch (...) {
94274       {
94275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94276       };
94277     }
94278   }
94279
94280 }
94281
94282
94283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
94284   unsigned int jresult ;
94285   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94286   bool result;
94287
94288   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94289   {
94290     try {
94291       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);
94292     } catch (std::out_of_range& e) {
94293       {
94294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94295       };
94296     } catch (std::exception& e) {
94297       {
94298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94299       };
94300     } catch (Dali::DaliException e) {
94301       {
94302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94303       };
94304     } catch (...) {
94305       {
94306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94307       };
94308     }
94309   }
94310
94311   jresult = result;
94312   return jresult;
94313 }
94314
94315
94316 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
94317   unsigned long jresult ;
94318   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94319   std::size_t result;
94320
94321   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94322   {
94323     try {
94324       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);
94325     } catch (std::out_of_range& e) {
94326       {
94327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94328       };
94329     } catch (std::exception& e) {
94330       {
94331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94332       };
94333     } catch (Dali::DaliException e) {
94334       {
94335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94336       };
94337     } catch (...) {
94338       {
94339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94340       };
94341     }
94342   }
94343
94344   jresult = (unsigned long)result;
94345   return jresult;
94346 }
94347
94348
94349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
94350   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94351   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94352
94353   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94354   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94355   {
94356     try {
94357       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
94358     } catch (std::out_of_range& e) {
94359       {
94360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94361       };
94362     } catch (std::exception& e) {
94363       {
94364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94365       };
94366     } catch (Dali::DaliException e) {
94367       {
94368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94369       };
94370     } catch (...) {
94371       {
94372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94373       };
94374     }
94375   }
94376
94377 }
94378
94379
94380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
94381   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94382   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94383
94384   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94385   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94386   {
94387     try {
94388       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
94389     } catch (std::out_of_range& e) {
94390       {
94391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94392       };
94393     } catch (std::exception& e) {
94394       {
94395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94396       };
94397     } catch (Dali::DaliException e) {
94398       {
94399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94400       };
94401     } catch (...) {
94402       {
94403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94404       };
94405     }
94406   }
94407
94408 }
94409
94410
94411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
94412   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94413   Dali::Actor arg2 ;
94414   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
94415   Dali::Actor *argp2 ;
94416
94417   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94418   argp2 = (Dali::Actor *)jarg2;
94419   if (!argp2) {
94420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94421     return ;
94422   }
94423   arg2 = *argp2;
94424   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
94425   {
94426     try {
94427       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
94428     } catch (std::out_of_range& e) {
94429       {
94430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94431       };
94432     } catch (std::exception& e) {
94433       {
94434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94435       };
94436     } catch (Dali::DaliException e) {
94437       {
94438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94439       };
94440     } catch (...) {
94441       {
94442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94443       };
94444     }
94445   }
94446
94447 }
94448
94449
94450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
94451   void * jresult ;
94452   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
94453
94454   {
94455     try {
94456       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
94457     } catch (std::out_of_range& e) {
94458       {
94459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94460       };
94461     } catch (std::exception& e) {
94462       {
94463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94464       };
94465     } catch (Dali::DaliException e) {
94466       {
94467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94468       };
94469     } catch (...) {
94470       {
94471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94472       };
94473     }
94474   }
94475
94476   jresult = (void *)result;
94477   return jresult;
94478 }
94479
94480
94481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
94482   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94483
94484   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94485   {
94486     try {
94487       delete arg1;
94488     } catch (std::out_of_range& e) {
94489       {
94490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94491       };
94492     } catch (std::exception& e) {
94493       {
94494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94495       };
94496     } catch (Dali::DaliException e) {
94497       {
94498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94499       };
94500     } catch (...) {
94501       {
94502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94503       };
94504     }
94505   }
94506
94507 }
94508
94509
94510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
94511   unsigned int jresult ;
94512   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94513   bool result;
94514
94515   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94516   {
94517     try {
94518       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94519     } catch (std::out_of_range& e) {
94520       {
94521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94522       };
94523     } catch (std::exception& e) {
94524       {
94525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94526       };
94527     } catch (Dali::DaliException e) {
94528       {
94529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94530       };
94531     } catch (...) {
94532       {
94533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94534       };
94535     }
94536   }
94537
94538   jresult = result;
94539   return jresult;
94540 }
94541
94542
94543 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
94544   unsigned long jresult ;
94545   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94546   std::size_t result;
94547
94548   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94549   {
94550     try {
94551       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94552     } catch (std::out_of_range& e) {
94553       {
94554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94555       };
94556     } catch (std::exception& e) {
94557       {
94558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94559       };
94560     } catch (Dali::DaliException e) {
94561       {
94562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94563       };
94564     } catch (...) {
94565       {
94566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94567       };
94568     }
94569   }
94570
94571   jresult = (unsigned long)result;
94572   return jresult;
94573 }
94574
94575
94576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
94577   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94578   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94579
94580   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94581   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94582   {
94583     try {
94584       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
94585     } catch (std::out_of_range& e) {
94586       {
94587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94588       };
94589     } catch (std::exception& e) {
94590       {
94591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94592       };
94593     } catch (Dali::DaliException e) {
94594       {
94595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94596       };
94597     } catch (...) {
94598       {
94599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94600       };
94601     }
94602   }
94603
94604 }
94605
94606
94607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94608   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94609   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94610
94611   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94612   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94613   {
94614     try {
94615       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
94616     } catch (std::out_of_range& e) {
94617       {
94618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94619       };
94620     } catch (std::exception& e) {
94621       {
94622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94623       };
94624     } catch (Dali::DaliException e) {
94625       {
94626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94627       };
94628     } catch (...) {
94629       {
94630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94631       };
94632     }
94633   }
94634
94635 }
94636
94637
94638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
94639   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94640   Dali::Actor arg2 ;
94641   Dali::Actor arg3 ;
94642   Dali::Actor *argp2 ;
94643   Dali::Actor *argp3 ;
94644
94645   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94646   argp2 = (Dali::Actor *)jarg2;
94647   if (!argp2) {
94648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94649     return ;
94650   }
94651   arg2 = *argp2;
94652   argp3 = (Dali::Actor *)jarg3;
94653   if (!argp3) {
94654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94655     return ;
94656   }
94657   arg3 = *argp3;
94658   {
94659     try {
94660       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
94661     } catch (std::out_of_range& e) {
94662       {
94663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94664       };
94665     } catch (std::exception& e) {
94666       {
94667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94668       };
94669     } catch (Dali::DaliException e) {
94670       {
94671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94672       };
94673     } catch (...) {
94674       {
94675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94676       };
94677     }
94678   }
94679
94680 }
94681
94682
94683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
94684   void * jresult ;
94685   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
94686
94687   {
94688     try {
94689       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
94690     } catch (std::out_of_range& e) {
94691       {
94692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94693       };
94694     } catch (std::exception& e) {
94695       {
94696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94697       };
94698     } catch (Dali::DaliException e) {
94699       {
94700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94701       };
94702     } catch (...) {
94703       {
94704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94705       };
94706     }
94707   }
94708
94709   jresult = (void *)result;
94710   return jresult;
94711 }
94712
94713
94714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
94715   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94716
94717   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94718   {
94719     try {
94720       delete arg1;
94721     } catch (std::out_of_range& e) {
94722       {
94723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94724       };
94725     } catch (std::exception& e) {
94726       {
94727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94728       };
94729     } catch (Dali::DaliException e) {
94730       {
94731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94732       };
94733     } catch (...) {
94734       {
94735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94736       };
94737     }
94738   }
94739
94740 }
94741
94742
94743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
94744   unsigned int jresult ;
94745   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94746   bool result;
94747
94748   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94749   {
94750     try {
94751       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94752     } catch (std::out_of_range& e) {
94753       {
94754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94755       };
94756     } catch (std::exception& e) {
94757       {
94758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94759       };
94760     } catch (Dali::DaliException e) {
94761       {
94762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94763       };
94764     } catch (...) {
94765       {
94766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94767       };
94768     }
94769   }
94770
94771   jresult = result;
94772   return jresult;
94773 }
94774
94775
94776 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
94777   unsigned long jresult ;
94778   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94779   std::size_t result;
94780
94781   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94782   {
94783     try {
94784       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94785     } catch (std::out_of_range& e) {
94786       {
94787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94788       };
94789     } catch (std::exception& e) {
94790       {
94791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94792       };
94793     } catch (Dali::DaliException e) {
94794       {
94795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94796       };
94797     } catch (...) {
94798       {
94799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94800       };
94801     }
94802   }
94803
94804   jresult = (unsigned long)result;
94805   return jresult;
94806 }
94807
94808
94809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
94810   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94811   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
94812
94813   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94814   arg2 = (void (*)(Dali::Actor,bool))jarg2;
94815   {
94816     try {
94817       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
94818     } catch (std::out_of_range& e) {
94819       {
94820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94821       };
94822     } catch (std::exception& e) {
94823       {
94824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94825       };
94826     } catch (Dali::DaliException e) {
94827       {
94828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94829       };
94830     } catch (...) {
94831       {
94832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94833       };
94834     }
94835   }
94836
94837 }
94838
94839
94840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94841   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94842   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
94843
94844   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94845   arg2 = (void (*)(Dali::Actor,bool))jarg2;
94846   {
94847     try {
94848       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
94849     } catch (std::out_of_range& e) {
94850       {
94851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94852       };
94853     } catch (std::exception& e) {
94854       {
94855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94856       };
94857     } catch (Dali::DaliException e) {
94858       {
94859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94860       };
94861     } catch (...) {
94862       {
94863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94864       };
94865     }
94866   }
94867
94868 }
94869
94870
94871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
94872   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94873   Dali::Actor arg2 ;
94874   bool arg3 ;
94875   Dali::Actor *argp2 ;
94876
94877   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94878   argp2 = (Dali::Actor *)jarg2;
94879   if (!argp2) {
94880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94881     return ;
94882   }
94883   arg2 = *argp2;
94884   arg3 = jarg3 ? true : false;
94885   {
94886     try {
94887       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
94888     } catch (std::out_of_range& e) {
94889       {
94890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94891       };
94892     } catch (std::exception& e) {
94893       {
94894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94895       };
94896     } catch (Dali::DaliException e) {
94897       {
94898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94899       };
94900     } catch (...) {
94901       {
94902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94903       };
94904     }
94905   }
94906
94907 }
94908
94909
94910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
94911   void * jresult ;
94912   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
94913
94914   {
94915     try {
94916       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
94917     } catch (std::out_of_range& e) {
94918       {
94919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94920       };
94921     } catch (std::exception& e) {
94922       {
94923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94924       };
94925     } catch (Dali::DaliException e) {
94926       {
94927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94928       };
94929     } catch (...) {
94930       {
94931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94932       };
94933     }
94934   }
94935
94936   jresult = (void *)result;
94937   return jresult;
94938 }
94939
94940
94941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
94942   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94943
94944   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94945   {
94946     try {
94947       delete arg1;
94948     } catch (std::out_of_range& e) {
94949       {
94950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94951       };
94952     } catch (std::exception& e) {
94953       {
94954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94955       };
94956     } catch (Dali::DaliException e) {
94957       {
94958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94959       };
94960     } catch (...) {
94961       {
94962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94963       };
94964     }
94965   }
94966
94967 }
94968
94969
94970 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
94971   unsigned int jresult ;
94972   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
94973   bool result;
94974
94975   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
94976   {
94977     try {
94978       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);
94979     } catch (std::out_of_range& e) {
94980       {
94981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94982       };
94983     } catch (std::exception& e) {
94984       {
94985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94986       };
94987     } catch (Dali::DaliException e) {
94988       {
94989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94990       };
94991     } catch (...) {
94992       {
94993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94994       };
94995     }
94996   }
94997
94998   jresult = result;
94999   return jresult;
95000 }
95001
95002
95003 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
95004   unsigned long jresult ;
95005   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95006   std::size_t result;
95007
95008   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95009   {
95010     try {
95011       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);
95012     } catch (std::out_of_range& e) {
95013       {
95014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95015       };
95016     } catch (std::exception& e) {
95017       {
95018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95019       };
95020     } catch (Dali::DaliException e) {
95021       {
95022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95023       };
95024     } catch (...) {
95025       {
95026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95027       };
95028     }
95029   }
95030
95031   jresult = (unsigned long)result;
95032   return jresult;
95033 }
95034
95035
95036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
95037   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95038   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95039
95040   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95041   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95042   {
95043     try {
95044       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
95045     } catch (std::out_of_range& e) {
95046       {
95047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95048       };
95049     } catch (std::exception& e) {
95050       {
95051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95052       };
95053     } catch (Dali::DaliException e) {
95054       {
95055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95056       };
95057     } catch (...) {
95058       {
95059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95060       };
95061     }
95062   }
95063
95064 }
95065
95066
95067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95068   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95069   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95070
95071   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95072   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95073   {
95074     try {
95075       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
95076     } catch (std::out_of_range& e) {
95077       {
95078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95079       };
95080     } catch (std::exception& e) {
95081       {
95082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95083       };
95084     } catch (Dali::DaliException e) {
95085       {
95086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95087       };
95088     } catch (...) {
95089       {
95090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95091       };
95092     }
95093   }
95094
95095 }
95096
95097
95098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95099   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95100   Dali::Toolkit::StyleManager arg2 ;
95101   Dali::StyleChange::Type arg3 ;
95102   Dali::Toolkit::StyleManager *argp2 ;
95103
95104   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95105   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
95106   if (!argp2) {
95107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
95108     return ;
95109   }
95110   arg2 = *argp2;
95111   arg3 = (Dali::StyleChange::Type)jarg3;
95112   {
95113     try {
95114       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
95115     } catch (std::out_of_range& e) {
95116       {
95117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95118       };
95119     } catch (std::exception& e) {
95120       {
95121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95122       };
95123     } catch (Dali::DaliException e) {
95124       {
95125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95126       };
95127     } catch (...) {
95128       {
95129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95130       };
95131     }
95132   }
95133
95134 }
95135
95136
95137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
95138   void * jresult ;
95139   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
95140
95141   {
95142     try {
95143       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
95144     } catch (std::out_of_range& e) {
95145       {
95146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95147       };
95148     } catch (std::exception& e) {
95149       {
95150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95151       };
95152     } catch (Dali::DaliException e) {
95153       {
95154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95155       };
95156     } catch (...) {
95157       {
95158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95159       };
95160     }
95161   }
95162
95163   jresult = (void *)result;
95164   return jresult;
95165 }
95166
95167
95168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
95169   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95170
95171   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95172   {
95173     try {
95174       delete arg1;
95175     } catch (std::out_of_range& e) {
95176       {
95177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95178       };
95179     } catch (std::exception& e) {
95180       {
95181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95182       };
95183     } catch (Dali::DaliException e) {
95184       {
95185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95186       };
95187     } catch (...) {
95188       {
95189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95190       };
95191     }
95192   }
95193
95194 }
95195
95196
95197 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
95198   unsigned int jresult ;
95199   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95200   bool result;
95201
95202   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95203   {
95204     try {
95205       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95206     } catch (std::out_of_range& e) {
95207       {
95208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95209       };
95210     } catch (std::exception& e) {
95211       {
95212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95213       };
95214     } catch (Dali::DaliException e) {
95215       {
95216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95217       };
95218     } catch (...) {
95219       {
95220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95221       };
95222     }
95223   }
95224
95225   jresult = result;
95226   return jresult;
95227 }
95228
95229
95230 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
95231   unsigned long jresult ;
95232   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95233   std::size_t result;
95234
95235   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95236   {
95237     try {
95238       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95239     } catch (std::out_of_range& e) {
95240       {
95241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95242       };
95243     } catch (std::exception& e) {
95244       {
95245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95246       };
95247     } catch (Dali::DaliException e) {
95248       {
95249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95250       };
95251     } catch (...) {
95252       {
95253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95254       };
95255     }
95256   }
95257
95258   jresult = (unsigned long)result;
95259   return jresult;
95260 }
95261
95262
95263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
95264   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95265   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95266
95267   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95268   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95269   {
95270     try {
95271       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
95272     } catch (std::out_of_range& e) {
95273       {
95274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95275       };
95276     } catch (std::exception& e) {
95277       {
95278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95279       };
95280     } catch (Dali::DaliException e) {
95281       {
95282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95283       };
95284     } catch (...) {
95285       {
95286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95287       };
95288     }
95289   }
95290
95291 }
95292
95293
95294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
95295   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95296   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95297
95298   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95299   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95300   {
95301     try {
95302       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
95303     } catch (std::out_of_range& e) {
95304       {
95305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95306       };
95307     } catch (std::exception& e) {
95308       {
95309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95310       };
95311     } catch (Dali::DaliException e) {
95312       {
95313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95314       };
95315     } catch (...) {
95316       {
95317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95318       };
95319     }
95320   }
95321
95322 }
95323
95324
95325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
95326   unsigned int jresult ;
95327   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95328   Dali::Toolkit::Button arg2 ;
95329   Dali::Toolkit::Button *argp2 ;
95330   bool result;
95331
95332   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95333   argp2 = (Dali::Toolkit::Button *)jarg2;
95334   if (!argp2) {
95335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
95336     return 0;
95337   }
95338   arg2 = *argp2;
95339   {
95340     try {
95341       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
95342     } catch (std::out_of_range& e) {
95343       {
95344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95345       };
95346     } catch (std::exception& e) {
95347       {
95348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95349       };
95350     } catch (Dali::DaliException e) {
95351       {
95352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95353       };
95354     } catch (...) {
95355       {
95356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95357       };
95358     }
95359   }
95360
95361   jresult = result;
95362   return jresult;
95363 }
95364
95365
95366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
95367   void * jresult ;
95368   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
95369
95370   {
95371     try {
95372       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
95373     } catch (std::out_of_range& e) {
95374       {
95375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95376       };
95377     } catch (std::exception& e) {
95378       {
95379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95380       };
95381     } catch (Dali::DaliException e) {
95382       {
95383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95384       };
95385     } catch (...) {
95386       {
95387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95388       };
95389     }
95390   }
95391
95392   jresult = (void *)result;
95393   return jresult;
95394 }
95395
95396
95397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
95398   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95399
95400   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95401   {
95402     try {
95403       delete arg1;
95404     } catch (std::out_of_range& e) {
95405       {
95406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95407       };
95408     } catch (std::exception& e) {
95409       {
95410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95411       };
95412     } catch (Dali::DaliException e) {
95413       {
95414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95415       };
95416     } catch (...) {
95417       {
95418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95419       };
95420     }
95421   }
95422
95423 }
95424
95425
95426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
95427   unsigned int jresult ;
95428   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95429   bool result;
95430
95431   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95432   {
95433     try {
95434       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95435     } catch (std::out_of_range& e) {
95436       {
95437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95438       };
95439     } catch (std::exception& e) {
95440       {
95441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95442       };
95443     } catch (Dali::DaliException e) {
95444       {
95445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95446       };
95447     } catch (...) {
95448       {
95449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95450       };
95451     }
95452   }
95453
95454   jresult = result;
95455   return jresult;
95456 }
95457
95458
95459 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
95460   unsigned long jresult ;
95461   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95462   std::size_t result;
95463
95464   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95465   {
95466     try {
95467       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95468     } catch (std::out_of_range& e) {
95469       {
95470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95471       };
95472     } catch (std::exception& e) {
95473       {
95474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95475       };
95476     } catch (Dali::DaliException e) {
95477       {
95478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95479       };
95480     } catch (...) {
95481       {
95482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95483       };
95484     }
95485   }
95486
95487   jresult = (unsigned long)result;
95488   return jresult;
95489 }
95490
95491
95492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
95493   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95494   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95495
95496   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95497   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95498   {
95499     try {
95500       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
95501     } catch (std::out_of_range& e) {
95502       {
95503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95504       };
95505     } catch (std::exception& e) {
95506       {
95507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95508       };
95509     } catch (Dali::DaliException e) {
95510       {
95511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95512       };
95513     } catch (...) {
95514       {
95515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95516       };
95517     }
95518   }
95519
95520 }
95521
95522
95523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
95524   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95525   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95526
95527   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95528   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95529   {
95530     try {
95531       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
95532     } catch (std::out_of_range& e) {
95533       {
95534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95535       };
95536     } catch (std::exception& e) {
95537       {
95538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95539       };
95540     } catch (Dali::DaliException e) {
95541       {
95542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95543       };
95544     } catch (...) {
95545       {
95546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95547       };
95548     }
95549   }
95550
95551 }
95552
95553
95554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
95555   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95556   Dali::Toolkit::GaussianBlurView arg2 ;
95557   Dali::Toolkit::GaussianBlurView *argp2 ;
95558
95559   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95560   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
95561   if (!argp2) {
95562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
95563     return ;
95564   }
95565   arg2 = *argp2;
95566   {
95567     try {
95568       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
95569     } catch (std::out_of_range& e) {
95570       {
95571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95572       };
95573     } catch (std::exception& e) {
95574       {
95575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95576       };
95577     } catch (Dali::DaliException e) {
95578       {
95579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95580       };
95581     } catch (...) {
95582       {
95583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95584       };
95585     }
95586   }
95587
95588 }
95589
95590
95591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
95592   void * jresult ;
95593   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
95594
95595   {
95596     try {
95597       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
95598     } catch (std::out_of_range& e) {
95599       {
95600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95601       };
95602     } catch (std::exception& e) {
95603       {
95604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95605       };
95606     } catch (Dali::DaliException e) {
95607       {
95608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95609       };
95610     } catch (...) {
95611       {
95612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95613       };
95614     }
95615   }
95616
95617   jresult = (void *)result;
95618   return jresult;
95619 }
95620
95621
95622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
95623   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95624
95625   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95626   {
95627     try {
95628       delete arg1;
95629     } catch (std::out_of_range& e) {
95630       {
95631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95632       };
95633     } catch (std::exception& e) {
95634       {
95635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95636       };
95637     } catch (Dali::DaliException e) {
95638       {
95639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95640       };
95641     } catch (...) {
95642       {
95643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95644       };
95645     }
95646   }
95647
95648 }
95649
95650
95651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
95652   unsigned int jresult ;
95653   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95654   bool result;
95655
95656   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95657   {
95658     try {
95659       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);
95660     } catch (std::out_of_range& e) {
95661       {
95662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95663       };
95664     } catch (std::exception& e) {
95665       {
95666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95667       };
95668     } catch (Dali::DaliException e) {
95669       {
95670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95671       };
95672     } catch (...) {
95673       {
95674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95675       };
95676     }
95677   }
95678
95679   jresult = result;
95680   return jresult;
95681 }
95682
95683
95684 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
95685   unsigned long jresult ;
95686   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95687   std::size_t result;
95688
95689   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95690   {
95691     try {
95692       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);
95693     } catch (std::out_of_range& e) {
95694       {
95695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95696       };
95697     } catch (std::exception& e) {
95698       {
95699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95700       };
95701     } catch (Dali::DaliException e) {
95702       {
95703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95704       };
95705     } catch (...) {
95706       {
95707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95708       };
95709     }
95710   }
95711
95712   jresult = (unsigned long)result;
95713   return jresult;
95714 }
95715
95716
95717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
95718   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95719   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95720
95721   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95722   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95723   {
95724     try {
95725       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
95726     } catch (std::out_of_range& e) {
95727       {
95728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95729       };
95730     } catch (std::exception& e) {
95731       {
95732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95733       };
95734     } catch (Dali::DaliException e) {
95735       {
95736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95737       };
95738     } catch (...) {
95739       {
95740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95741       };
95742     }
95743   }
95744
95745 }
95746
95747
95748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
95749   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95750   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95751
95752   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95753   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95754   {
95755     try {
95756       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95757     } catch (std::out_of_range& e) {
95758       {
95759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95760       };
95761     } catch (std::exception& e) {
95762       {
95763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95764       };
95765     } catch (Dali::DaliException e) {
95766       {
95767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95768       };
95769     } catch (...) {
95770       {
95771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95772       };
95773     }
95774   }
95775
95776 }
95777
95778
95779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
95780   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95781   Dali::Toolkit::PageTurnView arg2 ;
95782   unsigned int arg3 ;
95783   bool arg4 ;
95784   Dali::Toolkit::PageTurnView *argp2 ;
95785
95786   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95787   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
95788   if (!argp2) {
95789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
95790     return ;
95791   }
95792   arg2 = *argp2;
95793   arg3 = (unsigned int)jarg3;
95794   arg4 = jarg4 ? true : false;
95795   {
95796     try {
95797       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
95798     } catch (std::out_of_range& e) {
95799       {
95800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95801       };
95802     } catch (std::exception& e) {
95803       {
95804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95805       };
95806     } catch (Dali::DaliException e) {
95807       {
95808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95809       };
95810     } catch (...) {
95811       {
95812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95813       };
95814     }
95815   }
95816
95817 }
95818
95819
95820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
95821   void * jresult ;
95822   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
95823
95824   {
95825     try {
95826       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
95827     } catch (std::out_of_range& e) {
95828       {
95829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95830       };
95831     } catch (std::exception& e) {
95832       {
95833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95834       };
95835     } catch (Dali::DaliException e) {
95836       {
95837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95838       };
95839     } catch (...) {
95840       {
95841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95842       };
95843     }
95844   }
95845
95846   jresult = (void *)result;
95847   return jresult;
95848 }
95849
95850
95851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
95852   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95853
95854   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95855   {
95856     try {
95857       delete arg1;
95858     } catch (std::out_of_range& e) {
95859       {
95860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95861       };
95862     } catch (std::exception& e) {
95863       {
95864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95865       };
95866     } catch (Dali::DaliException e) {
95867       {
95868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95869       };
95870     } catch (...) {
95871       {
95872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95873       };
95874     }
95875   }
95876
95877 }
95878
95879
95880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
95881   unsigned int jresult ;
95882   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95883   bool result;
95884
95885   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95886   {
95887     try {
95888       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
95889     } catch (std::out_of_range& e) {
95890       {
95891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95892       };
95893     } catch (std::exception& e) {
95894       {
95895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95896       };
95897     } catch (Dali::DaliException e) {
95898       {
95899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95900       };
95901     } catch (...) {
95902       {
95903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95904       };
95905     }
95906   }
95907
95908   jresult = result;
95909   return jresult;
95910 }
95911
95912
95913 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
95914   unsigned long jresult ;
95915   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95916   std::size_t result;
95917
95918   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95919   {
95920     try {
95921       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
95922     } catch (std::out_of_range& e) {
95923       {
95924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95925       };
95926     } catch (std::exception& e) {
95927       {
95928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95929       };
95930     } catch (Dali::DaliException e) {
95931       {
95932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95933       };
95934     } catch (...) {
95935       {
95936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95937       };
95938     }
95939   }
95940
95941   jresult = (unsigned long)result;
95942   return jresult;
95943 }
95944
95945
95946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
95947   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95948   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
95949
95950   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95951   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
95952   {
95953     try {
95954       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
95955     } catch (std::out_of_range& e) {
95956       {
95957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95958       };
95959     } catch (std::exception& e) {
95960       {
95961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95962       };
95963     } catch (Dali::DaliException e) {
95964       {
95965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95966       };
95967     } catch (...) {
95968       {
95969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95970       };
95971     }
95972   }
95973
95974 }
95975
95976
95977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
95978   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95979   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
95980
95981   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95982   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
95983   {
95984     try {
95985       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
95986     } catch (std::out_of_range& e) {
95987       {
95988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95989       };
95990     } catch (std::exception& e) {
95991       {
95992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95993       };
95994     } catch (Dali::DaliException e) {
95995       {
95996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95997       };
95998     } catch (...) {
95999       {
96000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96001       };
96002     }
96003   }
96004
96005 }
96006
96007
96008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
96009   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96010   Dali::Toolkit::PageTurnView arg2 ;
96011   Dali::Toolkit::PageTurnView *argp2 ;
96012
96013   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96014   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96015   if (!argp2) {
96016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96017     return ;
96018   }
96019   arg2 = *argp2;
96020   {
96021     try {
96022       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
96023     } catch (std::out_of_range& e) {
96024       {
96025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96026       };
96027     } catch (std::exception& e) {
96028       {
96029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96030       };
96031     } catch (Dali::DaliException e) {
96032       {
96033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96034       };
96035     } catch (...) {
96036       {
96037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96038       };
96039     }
96040   }
96041
96042 }
96043
96044
96045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
96046   void * jresult ;
96047   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
96048
96049   {
96050     try {
96051       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
96052     } catch (std::out_of_range& e) {
96053       {
96054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96055       };
96056     } catch (std::exception& e) {
96057       {
96058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96059       };
96060     } catch (Dali::DaliException e) {
96061       {
96062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96063       };
96064     } catch (...) {
96065       {
96066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96067       };
96068     }
96069   }
96070
96071   jresult = (void *)result;
96072   return jresult;
96073 }
96074
96075
96076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
96077   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96078
96079   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96080   {
96081     try {
96082       delete arg1;
96083     } catch (std::out_of_range& e) {
96084       {
96085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96086       };
96087     } catch (std::exception& e) {
96088       {
96089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96090       };
96091     } catch (Dali::DaliException e) {
96092       {
96093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96094       };
96095     } catch (...) {
96096       {
96097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96098       };
96099     }
96100   }
96101
96102 }
96103
96104
96105 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
96106   unsigned int jresult ;
96107   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96108   bool result;
96109
96110   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96111   {
96112     try {
96113       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);
96114     } catch (std::out_of_range& e) {
96115       {
96116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96117       };
96118     } catch (std::exception& e) {
96119       {
96120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96121       };
96122     } catch (Dali::DaliException e) {
96123       {
96124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96125       };
96126     } catch (...) {
96127       {
96128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96129       };
96130     }
96131   }
96132
96133   jresult = result;
96134   return jresult;
96135 }
96136
96137
96138 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
96139   unsigned long jresult ;
96140   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96141   std::size_t result;
96142
96143   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96144   {
96145     try {
96146       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);
96147     } catch (std::out_of_range& e) {
96148       {
96149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96150       };
96151     } catch (std::exception& e) {
96152       {
96153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96154       };
96155     } catch (Dali::DaliException e) {
96156       {
96157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96158       };
96159     } catch (...) {
96160       {
96161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96162       };
96163     }
96164   }
96165
96166   jresult = (unsigned long)result;
96167   return jresult;
96168 }
96169
96170
96171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
96172   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96173   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96174
96175   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96176   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96177   {
96178     try {
96179       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
96180     } catch (std::out_of_range& e) {
96181       {
96182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96183       };
96184     } catch (std::exception& e) {
96185       {
96186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96187       };
96188     } catch (Dali::DaliException e) {
96189       {
96190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96191       };
96192     } catch (...) {
96193       {
96194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96195       };
96196     }
96197   }
96198
96199 }
96200
96201
96202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96203   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96204   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96205
96206   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96207   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96208   {
96209     try {
96210       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
96211     } catch (std::out_of_range& e) {
96212       {
96213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96214       };
96215     } catch (std::exception& e) {
96216       {
96217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96218       };
96219     } catch (Dali::DaliException e) {
96220       {
96221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96222       };
96223     } catch (...) {
96224       {
96225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96226       };
96227     }
96228   }
96229
96230 }
96231
96232
96233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
96234   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96235   Dali::Toolkit::ProgressBar arg2 ;
96236   float arg3 ;
96237   float arg4 ;
96238   Dali::Toolkit::ProgressBar *argp2 ;
96239
96240   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96241   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
96242   if (!argp2) {
96243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
96244     return ;
96245   }
96246   arg2 = *argp2;
96247   arg3 = (float)jarg3;
96248   arg4 = (float)jarg4;
96249   {
96250     try {
96251       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96252     } catch (std::out_of_range& e) {
96253       {
96254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96255       };
96256     } catch (std::exception& e) {
96257       {
96258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96259       };
96260     } catch (Dali::DaliException e) {
96261       {
96262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96263       };
96264     } catch (...) {
96265       {
96266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96267       };
96268     }
96269   }
96270
96271 }
96272
96273
96274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
96275   void * jresult ;
96276   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
96277
96278   {
96279     try {
96280       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
96281     } catch (std::out_of_range& e) {
96282       {
96283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96284       };
96285     } catch (std::exception& e) {
96286       {
96287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96288       };
96289     } catch (Dali::DaliException e) {
96290       {
96291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96292       };
96293     } catch (...) {
96294       {
96295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96296       };
96297     }
96298   }
96299
96300   jresult = (void *)result;
96301   return jresult;
96302 }
96303
96304
96305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
96306   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96307
96308   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96309   {
96310     try {
96311       delete arg1;
96312     } catch (std::out_of_range& e) {
96313       {
96314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96315       };
96316     } catch (std::exception& e) {
96317       {
96318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96319       };
96320     } catch (Dali::DaliException e) {
96321       {
96322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96323       };
96324     } catch (...) {
96325       {
96326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96327       };
96328     }
96329   }
96330
96331 }
96332
96333
96334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
96335   unsigned int jresult ;
96336   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96337   bool result;
96338
96339   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96340   {
96341     try {
96342       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);
96343     } catch (std::out_of_range& e) {
96344       {
96345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96346       };
96347     } catch (std::exception& e) {
96348       {
96349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96350       };
96351     } catch (Dali::DaliException e) {
96352       {
96353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96354       };
96355     } catch (...) {
96356       {
96357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96358       };
96359     }
96360   }
96361
96362   jresult = result;
96363   return jresult;
96364 }
96365
96366
96367 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
96368   unsigned long jresult ;
96369   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96370   std::size_t result;
96371
96372   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96373   {
96374     try {
96375       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);
96376     } catch (std::out_of_range& e) {
96377       {
96378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96379       };
96380     } catch (std::exception& e) {
96381       {
96382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96383       };
96384     } catch (Dali::DaliException e) {
96385       {
96386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96387       };
96388     } catch (...) {
96389       {
96390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96391       };
96392     }
96393   }
96394
96395   jresult = (unsigned long)result;
96396   return jresult;
96397 }
96398
96399
96400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
96401   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96402   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96403
96404   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96405   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96406   {
96407     try {
96408       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96409     } catch (std::out_of_range& e) {
96410       {
96411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96412       };
96413     } catch (std::exception& e) {
96414       {
96415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96416       };
96417     } catch (Dali::DaliException e) {
96418       {
96419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96420       };
96421     } catch (...) {
96422       {
96423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96424       };
96425     }
96426   }
96427
96428 }
96429
96430
96431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
96432   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96433   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96434
96435   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96436   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96437   {
96438     try {
96439       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96440     } catch (std::out_of_range& e) {
96441       {
96442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96443       };
96444     } catch (std::exception& e) {
96445       {
96446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96447       };
96448     } catch (Dali::DaliException e) {
96449       {
96450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96451       };
96452     } catch (...) {
96453       {
96454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96455       };
96456     }
96457   }
96458
96459 }
96460
96461
96462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
96463   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96464   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
96465
96466   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96467   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
96468   if (!arg2) {
96469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
96470     return ;
96471   }
96472   {
96473     try {
96474       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
96475     } catch (std::out_of_range& e) {
96476       {
96477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96478       };
96479     } catch (std::exception& e) {
96480       {
96481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96482       };
96483     } catch (Dali::DaliException e) {
96484       {
96485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96486       };
96487     } catch (...) {
96488       {
96489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96490       };
96491     }
96492   }
96493
96494 }
96495
96496
96497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
96498   void * jresult ;
96499   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
96500
96501   {
96502     try {
96503       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
96504     } catch (std::out_of_range& e) {
96505       {
96506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96507       };
96508     } catch (std::exception& e) {
96509       {
96510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96511       };
96512     } catch (Dali::DaliException e) {
96513       {
96514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96515       };
96516     } catch (...) {
96517       {
96518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96519       };
96520     }
96521   }
96522
96523   jresult = (void *)result;
96524   return jresult;
96525 }
96526
96527
96528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
96529   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96530
96531   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96532   {
96533     try {
96534       delete arg1;
96535     } catch (std::out_of_range& e) {
96536       {
96537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96538       };
96539     } catch (std::exception& e) {
96540       {
96541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96542       };
96543     } catch (Dali::DaliException e) {
96544       {
96545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96546       };
96547     } catch (...) {
96548       {
96549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96550       };
96551     }
96552   }
96553
96554 }
96555
96556
96557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
96558   unsigned int jresult ;
96559   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96560   bool result;
96561
96562   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96563   {
96564     try {
96565       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96566     } catch (std::out_of_range& e) {
96567       {
96568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96569       };
96570     } catch (std::exception& e) {
96571       {
96572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96573       };
96574     } catch (Dali::DaliException e) {
96575       {
96576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96577       };
96578     } catch (...) {
96579       {
96580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96581       };
96582     }
96583   }
96584
96585   jresult = result;
96586   return jresult;
96587 }
96588
96589
96590 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
96591   unsigned long jresult ;
96592   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96593   std::size_t result;
96594
96595   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96596   {
96597     try {
96598       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96599     } catch (std::out_of_range& e) {
96600       {
96601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96602       };
96603     } catch (std::exception& e) {
96604       {
96605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96606       };
96607     } catch (Dali::DaliException e) {
96608       {
96609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96610       };
96611     } catch (...) {
96612       {
96613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96614       };
96615     }
96616   }
96617
96618   jresult = (unsigned long)result;
96619   return jresult;
96620 }
96621
96622
96623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
96624   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96625   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96626
96627   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96628   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96629   {
96630     try {
96631       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96632     } catch (std::out_of_range& e) {
96633       {
96634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96635       };
96636     } catch (std::exception& e) {
96637       {
96638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96639       };
96640     } catch (Dali::DaliException e) {
96641       {
96642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96643       };
96644     } catch (...) {
96645       {
96646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96647       };
96648     }
96649   }
96650
96651 }
96652
96653
96654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
96655   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96656   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96657
96658   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96659   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96660   {
96661     try {
96662       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96663     } catch (std::out_of_range& e) {
96664       {
96665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96666       };
96667     } catch (std::exception& e) {
96668       {
96669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96670       };
96671     } catch (Dali::DaliException e) {
96672       {
96673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96674       };
96675     } catch (...) {
96676       {
96677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96678       };
96679     }
96680   }
96681
96682 }
96683
96684
96685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
96686   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96687   Dali::Vector2 *arg2 = 0 ;
96688
96689   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96690   arg2 = (Dali::Vector2 *)jarg2;
96691   if (!arg2) {
96692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
96693     return ;
96694   }
96695   {
96696     try {
96697       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
96698     } catch (std::out_of_range& e) {
96699       {
96700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96701       };
96702     } catch (std::exception& e) {
96703       {
96704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96705       };
96706     } catch (Dali::DaliException e) {
96707       {
96708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96709       };
96710     } catch (...) {
96711       {
96712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96713       };
96714     }
96715   }
96716
96717 }
96718
96719
96720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
96721   void * jresult ;
96722   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
96723
96724   {
96725     try {
96726       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
96727     } catch (std::out_of_range& e) {
96728       {
96729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96730       };
96731     } catch (std::exception& e) {
96732       {
96733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96734       };
96735     } catch (Dali::DaliException e) {
96736       {
96737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96738       };
96739     } catch (...) {
96740       {
96741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96742       };
96743     }
96744   }
96745
96746   jresult = (void *)result;
96747   return jresult;
96748 }
96749
96750
96751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
96752   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96753
96754   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96755   {
96756     try {
96757       delete arg1;
96758     } catch (std::out_of_range& e) {
96759       {
96760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96761       };
96762     } catch (std::exception& e) {
96763       {
96764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96765       };
96766     } catch (Dali::DaliException e) {
96767       {
96768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96769       };
96770     } catch (...) {
96771       {
96772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96773       };
96774     }
96775   }
96776
96777 }
96778
96779
96780
96781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
96782   unsigned int jresult ;
96783   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96784   bool result;
96785
96786   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96787   {
96788     try {
96789       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);
96790     } catch (std::out_of_range& e) {
96791       {
96792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96793       };
96794     } catch (std::exception& e) {
96795       {
96796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96797       };
96798     } catch (Dali::DaliException e) {
96799       {
96800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96801       };
96802     } catch (...) {
96803       {
96804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96805       };
96806     }
96807   }
96808
96809   jresult = result;
96810   return jresult;
96811 }
96812
96813
96814 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
96815   unsigned long jresult ;
96816   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96817   std::size_t result;
96818
96819   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96820   {
96821     try {
96822       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);
96823     } catch (std::out_of_range& e) {
96824       {
96825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96826       };
96827     } catch (std::exception& e) {
96828       {
96829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96830       };
96831     } catch (Dali::DaliException e) {
96832       {
96833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96834       };
96835     } catch (...) {
96836       {
96837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96838       };
96839     }
96840   }
96841
96842   jresult = (unsigned long)result;
96843   return jresult;
96844 }
96845
96846
96847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
96848   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96849   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
96850
96851   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96852   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
96853   {
96854     try {
96855       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96856     } catch (std::out_of_range& e) {
96857       {
96858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96859       };
96860     } catch (std::exception& e) {
96861       {
96862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96863       };
96864     } catch (Dali::DaliException e) {
96865       {
96866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96867       };
96868     } catch (...) {
96869       {
96870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96871       };
96872     }
96873   }
96874
96875 }
96876
96877
96878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
96879   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96880   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
96881
96882   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96883   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
96884   {
96885     try {
96886       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96887     } catch (std::out_of_range& e) {
96888       {
96889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96890       };
96891     } catch (std::exception& e) {
96892       {
96893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96894       };
96895     } catch (Dali::DaliException e) {
96896       {
96897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96898       };
96899     } catch (...) {
96900       {
96901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96902       };
96903     }
96904   }
96905
96906 }
96907
96908
96909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
96910   unsigned int jresult ;
96911   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96912   Dali::Toolkit::Control arg2 ;
96913   Dali::KeyEvent *arg3 = 0 ;
96914   Dali::Toolkit::Control *argp2 ;
96915   bool result;
96916
96917   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96918   argp2 = (Dali::Toolkit::Control *)jarg2;
96919   if (!argp2) {
96920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
96921     return 0;
96922   }
96923   arg2 = *argp2;
96924   arg3 = (Dali::KeyEvent *)jarg3;
96925   if (!arg3) {
96926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
96927     return 0;
96928   }
96929   {
96930     try {
96931       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);
96932     } catch (std::out_of_range& e) {
96933       {
96934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96935       };
96936     } catch (std::exception& e) {
96937       {
96938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96939       };
96940     } catch (Dali::DaliException e) {
96941       {
96942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96943       };
96944     } catch (...) {
96945       {
96946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96947       };
96948     }
96949   }
96950
96951   jresult = result;
96952   return jresult;
96953 }
96954
96955
96956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
96957   void * jresult ;
96958   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
96959
96960   {
96961     try {
96962       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
96963     } catch (std::out_of_range& e) {
96964       {
96965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96966       };
96967     } catch (std::exception& e) {
96968       {
96969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96970       };
96971     } catch (Dali::DaliException e) {
96972       {
96973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96974       };
96975     } catch (...) {
96976       {
96977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96978       };
96979     }
96980   }
96981
96982   jresult = (void *)result;
96983   return jresult;
96984 }
96985
96986
96987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
96988   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96989
96990   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96991   {
96992     try {
96993       delete arg1;
96994     } catch (std::out_of_range& e) {
96995       {
96996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96997       };
96998     } catch (std::exception& e) {
96999       {
97000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97001       };
97002     } catch (Dali::DaliException e) {
97003       {
97004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97005       };
97006     } catch (...) {
97007       {
97008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97009       };
97010     }
97011   }
97012
97013 }
97014
97015
97016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
97017   unsigned int jresult ;
97018   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97019   bool result;
97020
97021   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97022   {
97023     try {
97024       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97025     } catch (std::out_of_range& e) {
97026       {
97027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97028       };
97029     } catch (std::exception& e) {
97030       {
97031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97032       };
97033     } catch (Dali::DaliException e) {
97034       {
97035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97036       };
97037     } catch (...) {
97038       {
97039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97040       };
97041     }
97042   }
97043
97044   jresult = result;
97045   return jresult;
97046 }
97047
97048
97049 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
97050   unsigned long jresult ;
97051   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97052   std::size_t result;
97053
97054   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97055   {
97056     try {
97057       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97058     } catch (std::out_of_range& e) {
97059       {
97060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97061       };
97062     } catch (std::exception& e) {
97063       {
97064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97065       };
97066     } catch (Dali::DaliException e) {
97067       {
97068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97069       };
97070     } catch (...) {
97071       {
97072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97073       };
97074     }
97075   }
97076
97077   jresult = (unsigned long)result;
97078   return jresult;
97079 }
97080
97081
97082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
97083   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97084   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97085
97086   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97087   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97088   {
97089     try {
97090       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
97091     } catch (std::out_of_range& e) {
97092       {
97093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97094       };
97095     } catch (std::exception& e) {
97096       {
97097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97098       };
97099     } catch (Dali::DaliException e) {
97100       {
97101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97102       };
97103     } catch (...) {
97104       {
97105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97106       };
97107     }
97108   }
97109
97110 }
97111
97112
97113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
97114   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97115   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97116
97117   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97118   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97119   {
97120     try {
97121       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
97122     } catch (std::out_of_range& e) {
97123       {
97124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97125       };
97126     } catch (std::exception& e) {
97127       {
97128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97129       };
97130     } catch (Dali::DaliException e) {
97131       {
97132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97133       };
97134     } catch (...) {
97135       {
97136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97137       };
97138     }
97139   }
97140
97141 }
97142
97143
97144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
97145   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97146   Dali::Toolkit::Control arg2 ;
97147   Dali::Toolkit::Control *argp2 ;
97148
97149   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97150   argp2 = (Dali::Toolkit::Control *)jarg2;
97151   if (!argp2) {
97152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97153     return ;
97154   }
97155   arg2 = *argp2;
97156   {
97157     try {
97158       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
97159     } catch (std::out_of_range& e) {
97160       {
97161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97162       };
97163     } catch (std::exception& e) {
97164       {
97165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97166       };
97167     } catch (Dali::DaliException e) {
97168       {
97169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97170       };
97171     } catch (...) {
97172       {
97173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97174       };
97175     }
97176   }
97177
97178 }
97179
97180
97181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
97182   void * jresult ;
97183   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
97184
97185   {
97186     try {
97187       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
97188     } catch (std::out_of_range& e) {
97189       {
97190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97191       };
97192     } catch (std::exception& e) {
97193       {
97194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97195       };
97196     } catch (Dali::DaliException e) {
97197       {
97198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97199       };
97200     } catch (...) {
97201       {
97202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97203       };
97204     }
97205   }
97206
97207   jresult = (void *)result;
97208   return jresult;
97209 }
97210
97211
97212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
97213   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97214
97215   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97216   {
97217     try {
97218       delete arg1;
97219     } catch (std::out_of_range& e) {
97220       {
97221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97222       };
97223     } catch (std::exception& e) {
97224       {
97225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97226       };
97227     } catch (Dali::DaliException e) {
97228       {
97229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97230       };
97231     } catch (...) {
97232       {
97233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97234       };
97235     }
97236   }
97237
97238 }
97239
97240
97241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
97242   unsigned int jresult ;
97243   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97244   bool result;
97245
97246   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97247   {
97248     try {
97249       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97250     } catch (std::out_of_range& e) {
97251       {
97252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97253       };
97254     } catch (std::exception& e) {
97255       {
97256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97257       };
97258     } catch (Dali::DaliException e) {
97259       {
97260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97261       };
97262     } catch (...) {
97263       {
97264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97265       };
97266     }
97267   }
97268
97269   jresult = result;
97270   return jresult;
97271 }
97272
97273
97274 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
97275   unsigned long jresult ;
97276   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97277   std::size_t result;
97278
97279   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97280   {
97281     try {
97282       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97283     } catch (std::out_of_range& e) {
97284       {
97285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97286       };
97287     } catch (std::exception& e) {
97288       {
97289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97290       };
97291     } catch (Dali::DaliException e) {
97292       {
97293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97294       };
97295     } catch (...) {
97296       {
97297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97298       };
97299     }
97300   }
97301
97302   jresult = (unsigned long)result;
97303   return jresult;
97304 }
97305
97306
97307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
97308   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97309   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97310
97311   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97312   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97313   {
97314     try {
97315       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
97316     } catch (std::out_of_range& e) {
97317       {
97318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97319       };
97320     } catch (std::exception& e) {
97321       {
97322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97323       };
97324     } catch (Dali::DaliException e) {
97325       {
97326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97327       };
97328     } catch (...) {
97329       {
97330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97331       };
97332     }
97333   }
97334
97335 }
97336
97337
97338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
97339   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97340   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97341
97342   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97343   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97344   {
97345     try {
97346       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
97347     } catch (std::out_of_range& e) {
97348       {
97349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97350       };
97351     } catch (std::exception& e) {
97352       {
97353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97354       };
97355     } catch (Dali::DaliException e) {
97356       {
97357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97358       };
97359     } catch (...) {
97360       {
97361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97362       };
97363     }
97364   }
97365
97366 }
97367
97368
97369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
97370   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97371   Dali::Toolkit::VideoView *arg2 = 0 ;
97372
97373   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97374   arg2 = (Dali::Toolkit::VideoView *)jarg2;
97375   if (!arg2) {
97376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
97377     return ;
97378   }
97379   {
97380     try {
97381       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
97382     } catch (std::out_of_range& e) {
97383       {
97384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97385       };
97386     } catch (std::exception& e) {
97387       {
97388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97389       };
97390     } catch (Dali::DaliException e) {
97391       {
97392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97393       };
97394     } catch (...) {
97395       {
97396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97397       };
97398     }
97399   }
97400
97401 }
97402
97403
97404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
97405   void * jresult ;
97406   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
97407
97408   {
97409     try {
97410       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
97411     } catch (std::out_of_range& e) {
97412       {
97413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97414       };
97415     } catch (std::exception& e) {
97416       {
97417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97418       };
97419     } catch (Dali::DaliException e) {
97420       {
97421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97422       };
97423     } catch (...) {
97424       {
97425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97426       };
97427     }
97428   }
97429
97430   jresult = (void *)result;
97431   return jresult;
97432 }
97433
97434
97435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
97436   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97437
97438   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97439   {
97440     try {
97441       delete arg1;
97442     } catch (std::out_of_range& e) {
97443       {
97444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97445       };
97446     } catch (std::exception& e) {
97447       {
97448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97449       };
97450     } catch (Dali::DaliException e) {
97451       {
97452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97453       };
97454     } catch (...) {
97455       {
97456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97457       };
97458     }
97459   }
97460
97461 }
97462
97463
97464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
97465   unsigned int jresult ;
97466   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97467   bool result;
97468
97469   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97470   {
97471     try {
97472       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97473     } catch (std::out_of_range& e) {
97474       {
97475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97476       };
97477     } catch (std::exception& e) {
97478       {
97479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97480       };
97481     } catch (Dali::DaliException e) {
97482       {
97483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97484       };
97485     } catch (...) {
97486       {
97487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97488       };
97489     }
97490   }
97491
97492   jresult = result;
97493   return jresult;
97494 }
97495
97496
97497 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
97498   unsigned long jresult ;
97499   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97500   std::size_t result;
97501
97502   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97503   {
97504     try {
97505       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97506     } catch (std::out_of_range& e) {
97507       {
97508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97509       };
97510     } catch (std::exception& e) {
97511       {
97512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97513       };
97514     } catch (Dali::DaliException e) {
97515       {
97516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97517       };
97518     } catch (...) {
97519       {
97520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97521       };
97522     }
97523   }
97524
97525   jresult = (unsigned long)result;
97526   return jresult;
97527 }
97528
97529
97530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97531   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97532   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97533
97534   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97535   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97536   {
97537     try {
97538       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
97539     } catch (std::out_of_range& e) {
97540       {
97541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97542       };
97543     } catch (std::exception& e) {
97544       {
97545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97546       };
97547     } catch (Dali::DaliException e) {
97548       {
97549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97550       };
97551     } catch (...) {
97552       {
97553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97554       };
97555     }
97556   }
97557
97558 }
97559
97560
97561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97562   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97563   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97564
97565   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97566   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97567   {
97568     try {
97569       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97570     } catch (std::out_of_range& e) {
97571       {
97572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97573       };
97574     } catch (std::exception& e) {
97575       {
97576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97577       };
97578     } catch (Dali::DaliException e) {
97579       {
97580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97581       };
97582     } catch (...) {
97583       {
97584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97585       };
97586     }
97587   }
97588
97589 }
97590
97591
97592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
97593   unsigned int jresult ;
97594   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97595   Dali::Toolkit::Slider arg2 ;
97596   float arg3 ;
97597   Dali::Toolkit::Slider *argp2 ;
97598   bool result;
97599
97600   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97601   argp2 = (Dali::Toolkit::Slider *)jarg2;
97602   if (!argp2) {
97603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
97604     return 0;
97605   }
97606   arg2 = *argp2;
97607   arg3 = (float)jarg3;
97608   {
97609     try {
97610       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
97611     } catch (std::out_of_range& e) {
97612       {
97613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97614       };
97615     } catch (std::exception& e) {
97616       {
97617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97618       };
97619     } catch (Dali::DaliException e) {
97620       {
97621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97622       };
97623     } catch (...) {
97624       {
97625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97626       };
97627     }
97628   }
97629
97630   jresult = result;
97631   return jresult;
97632 }
97633
97634
97635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
97636   void * jresult ;
97637   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
97638
97639   {
97640     try {
97641       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
97642     } catch (std::out_of_range& e) {
97643       {
97644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97645       };
97646     } catch (std::exception& e) {
97647       {
97648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97649       };
97650     } catch (Dali::DaliException e) {
97651       {
97652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97653       };
97654     } catch (...) {
97655       {
97656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97657       };
97658     }
97659   }
97660
97661   jresult = (void *)result;
97662   return jresult;
97663 }
97664
97665
97666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
97667   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97668
97669   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97670   {
97671     try {
97672       delete arg1;
97673     } catch (std::out_of_range& e) {
97674       {
97675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97676       };
97677     } catch (std::exception& e) {
97678       {
97679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97680       };
97681     } catch (Dali::DaliException e) {
97682       {
97683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97684       };
97685     } catch (...) {
97686       {
97687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97688       };
97689     }
97690   }
97691
97692 }
97693
97694
97695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
97696   unsigned int jresult ;
97697   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97698   bool result;
97699
97700   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97701   {
97702     try {
97703       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97704     } catch (std::out_of_range& e) {
97705       {
97706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97707       };
97708     } catch (std::exception& e) {
97709       {
97710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97711       };
97712     } catch (Dali::DaliException e) {
97713       {
97714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97715       };
97716     } catch (...) {
97717       {
97718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97719       };
97720     }
97721   }
97722
97723   jresult = result;
97724   return jresult;
97725 }
97726
97727
97728 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
97729   unsigned long jresult ;
97730   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97731   std::size_t result;
97732
97733   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97734   {
97735     try {
97736       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97737     } catch (std::out_of_range& e) {
97738       {
97739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97740       };
97741     } catch (std::exception& e) {
97742       {
97743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97744       };
97745     } catch (Dali::DaliException e) {
97746       {
97747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97748       };
97749     } catch (...) {
97750       {
97751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97752       };
97753     }
97754   }
97755
97756   jresult = (unsigned long)result;
97757   return jresult;
97758 }
97759
97760
97761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
97762   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97763   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97764
97765   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97766   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97767   {
97768     try {
97769       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
97770     } catch (std::out_of_range& e) {
97771       {
97772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97773       };
97774     } catch (std::exception& e) {
97775       {
97776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97777       };
97778     } catch (Dali::DaliException e) {
97779       {
97780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97781       };
97782     } catch (...) {
97783       {
97784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97785       };
97786     }
97787   }
97788
97789 }
97790
97791
97792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
97793   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97794   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97795
97796   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97797   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97798   {
97799     try {
97800       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
97801     } catch (std::out_of_range& e) {
97802       {
97803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97804       };
97805     } catch (std::exception& e) {
97806       {
97807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97808       };
97809     } catch (Dali::DaliException e) {
97810       {
97811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97812       };
97813     } catch (...) {
97814       {
97815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97816       };
97817     }
97818   }
97819
97820 }
97821
97822
97823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
97824   unsigned int jresult ;
97825   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97826   Dali::Toolkit::Slider arg2 ;
97827   int arg3 ;
97828   Dali::Toolkit::Slider *argp2 ;
97829   bool result;
97830
97831   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97832   argp2 = (Dali::Toolkit::Slider *)jarg2;
97833   if (!argp2) {
97834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
97835     return 0;
97836   }
97837   arg2 = *argp2;
97838   arg3 = (int)jarg3;
97839   {
97840     try {
97841       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
97842     } catch (std::out_of_range& e) {
97843       {
97844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97845       };
97846     } catch (std::exception& e) {
97847       {
97848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97849       };
97850     } catch (Dali::DaliException e) {
97851       {
97852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97853       };
97854     } catch (...) {
97855       {
97856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97857       };
97858     }
97859   }
97860
97861   jresult = result;
97862   return jresult;
97863 }
97864
97865
97866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
97867   void * jresult ;
97868   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
97869
97870   {
97871     try {
97872       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
97873     } catch (std::out_of_range& e) {
97874       {
97875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97876       };
97877     } catch (std::exception& e) {
97878       {
97879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97880       };
97881     } catch (Dali::DaliException e) {
97882       {
97883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97884       };
97885     } catch (...) {
97886       {
97887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97888       };
97889     }
97890   }
97891
97892   jresult = (void *)result;
97893   return jresult;
97894 }
97895
97896
97897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
97898   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97899
97900   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97901   {
97902     try {
97903       delete arg1;
97904     } catch (std::out_of_range& e) {
97905       {
97906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97907       };
97908     } catch (std::exception& e) {
97909       {
97910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97911       };
97912     } catch (Dali::DaliException e) {
97913       {
97914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97915       };
97916     } catch (...) {
97917       {
97918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97919       };
97920     }
97921   }
97922
97923 }
97924
97925
97926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
97927   void * jresult ;
97928   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
97929
97930   {
97931     try {
97932       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
97933     } catch (std::out_of_range& e) {
97934       {
97935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97936       };
97937     } catch (std::exception& e) {
97938       {
97939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97940       };
97941     } catch (Dali::DaliException e) {
97942       {
97943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97944       };
97945     } catch (...) {
97946       {
97947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97948       };
97949     }
97950   }
97951
97952   jresult = (void *)result;
97953   return jresult;
97954 }
97955
97956
97957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
97958   void * jresult ;
97959   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
97960   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
97961
97962   arg1 = (Dali::Toolkit::Ruler *)jarg1;
97963   {
97964     try {
97965       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
97966     } catch (std::out_of_range& e) {
97967       {
97968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97969       };
97970     } catch (std::exception& e) {
97971       {
97972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97973       };
97974     } catch (Dali::DaliException e) {
97975       {
97976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97977       };
97978     } catch (...) {
97979       {
97980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97981       };
97982     }
97983   }
97984
97985   jresult = (void *)result;
97986   return jresult;
97987 }
97988
97989
97990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
97991   void * jresult ;
97992   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
97993   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
97994
97995   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97996   if (!arg1) {
97997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
97998     return 0;
97999   }
98000   {
98001     try {
98002       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
98003     } catch (std::out_of_range& e) {
98004       {
98005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98006       };
98007     } catch (std::exception& e) {
98008       {
98009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98010       };
98011     } catch (Dali::DaliException e) {
98012       {
98013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98014       };
98015     } catch (...) {
98016       {
98017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98018       };
98019     }
98020   }
98021
98022   jresult = (void *)result;
98023   return jresult;
98024 }
98025
98026
98027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
98028   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98029
98030   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98031   {
98032     try {
98033       delete arg1;
98034     } catch (std::out_of_range& e) {
98035       {
98036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98037       };
98038     } catch (std::exception& e) {
98039       {
98040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98041       };
98042     } catch (Dali::DaliException e) {
98043       {
98044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98045       };
98046     } catch (...) {
98047       {
98048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98049       };
98050     }
98051   }
98052
98053 }
98054
98055
98056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
98057   void * jresult ;
98058   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98059   Dali::Toolkit::Ruler *result = 0 ;
98060
98061   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98062   {
98063     try {
98064       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
98065     } catch (std::out_of_range& e) {
98066       {
98067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98068       };
98069     } catch (std::exception& e) {
98070       {
98071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98072       };
98073     } catch (Dali::DaliException e) {
98074       {
98075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98076       };
98077     } catch (...) {
98078       {
98079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98080       };
98081     }
98082   }
98083
98084   jresult = (void *)result;
98085   return jresult;
98086 }
98087
98088
98089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
98090   void * jresult ;
98091   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98092   Dali::Toolkit::Ruler *result = 0 ;
98093
98094   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98095   {
98096     try {
98097       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
98098     } catch (std::out_of_range& e) {
98099       {
98100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98101       };
98102     } catch (std::exception& e) {
98103       {
98104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98105       };
98106     } catch (Dali::DaliException e) {
98107       {
98108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98109       };
98110     } catch (...) {
98111       {
98112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98113       };
98114     }
98115   }
98116
98117   jresult = (void *)result;
98118   return jresult;
98119 }
98120
98121
98122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
98123   void * jresult ;
98124   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98125   Dali::Toolkit::Ruler *result = 0 ;
98126
98127   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98128   {
98129     try {
98130       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
98131     } catch (std::out_of_range& e) {
98132       {
98133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98134       };
98135     } catch (std::exception& e) {
98136       {
98137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98138       };
98139     } catch (Dali::DaliException e) {
98140       {
98141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98142       };
98143     } catch (...) {
98144       {
98145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98146       };
98147     }
98148   }
98149
98150   jresult = (void *)result;
98151   return jresult;
98152 }
98153
98154
98155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
98156   void * jresult ;
98157   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98158   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
98159   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98160
98161   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98162   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
98163   if (!arg2) {
98164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98165     return 0;
98166   }
98167   {
98168     try {
98169       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
98170     } catch (std::out_of_range& e) {
98171       {
98172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98173       };
98174     } catch (std::exception& e) {
98175       {
98176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98177       };
98178     } catch (Dali::DaliException e) {
98179       {
98180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98181       };
98182     } catch (...) {
98183       {
98184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98185       };
98186     }
98187   }
98188
98189   jresult = (void *)result;
98190   return jresult;
98191 }
98192
98193
98194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
98195   void * jresult ;
98196   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98197   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98198   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98199
98200   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98201   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98202   {
98203     try {
98204       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
98205     } catch (std::out_of_range& e) {
98206       {
98207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98208       };
98209     } catch (std::exception& e) {
98210       {
98211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98212       };
98213     } catch (Dali::DaliException e) {
98214       {
98215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98216       };
98217     } catch (...) {
98218       {
98219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98220       };
98221     }
98222   }
98223
98224   jresult = (void *)result;
98225   return jresult;
98226 }
98227
98228
98229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
98230   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98231
98232   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98233   {
98234     try {
98235       (arg1)->Reset();
98236     } catch (std::out_of_range& e) {
98237       {
98238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98239       };
98240     } catch (std::exception& e) {
98241       {
98242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98243       };
98244     } catch (Dali::DaliException e) {
98245       {
98246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98247       };
98248     } catch (...) {
98249       {
98250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98251       };
98252     }
98253   }
98254
98255 }
98256
98257
98258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
98259   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98260   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98261
98262   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98263   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98264   {
98265     try {
98266       (arg1)->Reset(arg2);
98267     } catch (std::out_of_range& e) {
98268       {
98269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98270       };
98271     } catch (std::exception& e) {
98272       {
98273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98274       };
98275     } catch (Dali::DaliException e) {
98276       {
98277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98278       };
98279     } catch (...) {
98280       {
98281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98282       };
98283     }
98284   }
98285
98286 }
98287
98288
98289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
98290   void * jresult ;
98291   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98292   Dali::Toolkit::Ruler *result = 0 ;
98293
98294   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98295   {
98296     try {
98297       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
98298     } catch (std::out_of_range& e) {
98299       {
98300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98301       };
98302     } catch (std::exception& e) {
98303       {
98304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98305       };
98306     } catch (Dali::DaliException e) {
98307       {
98308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98309       };
98310     } catch (...) {
98311       {
98312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98313       };
98314     }
98315   }
98316
98317   jresult = (void *)result;
98318   return jresult;
98319 }
98320
98321
98322 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
98323   float jresult ;
98324   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98325   float arg2 ;
98326   float arg3 ;
98327   float result;
98328
98329   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98330   arg2 = (float)jarg2;
98331   arg3 = (float)jarg3;
98332   {
98333     try {
98334       result = (float)(*arg1)->Snap(arg2,arg3);
98335     } catch (std::out_of_range& e) {
98336       {
98337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98338       };
98339     } catch (std::exception& e) {
98340       {
98341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98342       };
98343     } catch (Dali::DaliException e) {
98344       {
98345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98346       };
98347     } catch (...) {
98348       {
98349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98350       };
98351     }
98352   }
98353
98354   jresult = result;
98355   return jresult;
98356 }
98357
98358
98359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
98360   float jresult ;
98361   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98362   float arg2 ;
98363   float result;
98364
98365   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98366   arg2 = (float)jarg2;
98367   {
98368     try {
98369       result = (float)(*arg1)->Snap(arg2);
98370     } catch (std::out_of_range& e) {
98371       {
98372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98373       };
98374     } catch (std::exception& e) {
98375       {
98376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98377       };
98378     } catch (Dali::DaliException e) {
98379       {
98380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98381       };
98382     } catch (...) {
98383       {
98384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98385       };
98386     }
98387   }
98388
98389   jresult = result;
98390   return jresult;
98391 }
98392
98393
98394 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
98395   float jresult ;
98396   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98397   unsigned int arg2 ;
98398   unsigned int *arg3 = 0 ;
98399   bool arg4 ;
98400   float result;
98401
98402   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98403   arg2 = (unsigned int)jarg2;
98404   arg3 = (unsigned int *)jarg3;
98405   arg4 = jarg4 ? true : false;
98406   {
98407     try {
98408       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
98409     } catch (std::out_of_range& e) {
98410       {
98411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98412       };
98413     } catch (std::exception& e) {
98414       {
98415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98416       };
98417     } catch (Dali::DaliException e) {
98418       {
98419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98420       };
98421     } catch (...) {
98422       {
98423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98424       };
98425     }
98426   }
98427
98428   jresult = result;
98429   return jresult;
98430 }
98431
98432
98433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
98434   unsigned int jresult ;
98435   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98436   float arg2 ;
98437   bool arg3 ;
98438   unsigned int result;
98439
98440   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98441   arg2 = (float)jarg2;
98442   arg3 = jarg3 ? true : false;
98443   {
98444     try {
98445       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
98446     } catch (std::out_of_range& e) {
98447       {
98448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98449       };
98450     } catch (std::exception& e) {
98451       {
98452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98453       };
98454     } catch (Dali::DaliException e) {
98455       {
98456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98457       };
98458     } catch (...) {
98459       {
98460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98461       };
98462     }
98463   }
98464
98465   jresult = result;
98466   return jresult;
98467 }
98468
98469
98470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
98471   unsigned int jresult ;
98472   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98473   unsigned int result;
98474
98475   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98476   {
98477     try {
98478       result = (unsigned int)(*arg1)->GetTotalPages();
98479     } catch (std::out_of_range& e) {
98480       {
98481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98482       };
98483     } catch (std::exception& e) {
98484       {
98485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98486       };
98487     } catch (Dali::DaliException e) {
98488       {
98489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98490       };
98491     } catch (...) {
98492       {
98493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98494       };
98495     }
98496   }
98497
98498   jresult = result;
98499   return jresult;
98500 }
98501
98502
98503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
98504   int jresult ;
98505   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98506   Dali::Toolkit::Ruler::RulerType result;
98507
98508   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98509   {
98510     try {
98511       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
98512     } catch (std::out_of_range& e) {
98513       {
98514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98515       };
98516     } catch (std::exception& e) {
98517       {
98518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98519       };
98520     } catch (Dali::DaliException e) {
98521       {
98522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98523       };
98524     } catch (...) {
98525       {
98526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98527       };
98528     }
98529   }
98530
98531   jresult = (int)result;
98532   return jresult;
98533 }
98534
98535
98536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
98537   unsigned int jresult ;
98538   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98539   bool result;
98540
98541   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98542   {
98543     try {
98544       result = (bool)(*arg1)->IsEnabled();
98545     } catch (std::out_of_range& e) {
98546       {
98547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98548       };
98549     } catch (std::exception& e) {
98550       {
98551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98552       };
98553     } catch (Dali::DaliException e) {
98554       {
98555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98556       };
98557     } catch (...) {
98558       {
98559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98560       };
98561     }
98562   }
98563
98564   jresult = result;
98565   return jresult;
98566 }
98567
98568
98569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
98570   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98571
98572   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98573   {
98574     try {
98575       (*arg1)->Enable();
98576     } catch (std::out_of_range& e) {
98577       {
98578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98579       };
98580     } catch (std::exception& e) {
98581       {
98582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98583       };
98584     } catch (Dali::DaliException e) {
98585       {
98586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98587       };
98588     } catch (...) {
98589       {
98590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98591       };
98592     }
98593   }
98594
98595 }
98596
98597
98598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
98599   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98600
98601   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98602   {
98603     try {
98604       (*arg1)->Disable();
98605     } catch (std::out_of_range& e) {
98606       {
98607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98608       };
98609     } catch (std::exception& e) {
98610       {
98611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98612       };
98613     } catch (Dali::DaliException e) {
98614       {
98615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98616       };
98617     } catch (...) {
98618       {
98619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98620       };
98621     }
98622   }
98623
98624 }
98625
98626
98627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
98628   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98629   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
98630   Dali::Toolkit::RulerDomain *argp2 ;
98631
98632   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98633   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
98634   if (!argp2) {
98635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
98636     return ;
98637   }
98638   arg2 = *argp2;
98639   {
98640     try {
98641       (*arg1)->SetDomain(arg2);
98642     } catch (std::out_of_range& e) {
98643       {
98644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98645       };
98646     } catch (std::exception& e) {
98647       {
98648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98649       };
98650     } catch (Dali::DaliException e) {
98651       {
98652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98653       };
98654     } catch (...) {
98655       {
98656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98657       };
98658     }
98659   }
98660
98661 }
98662
98663
98664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
98665   void * jresult ;
98666   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98667   Dali::Toolkit::RulerDomain *result = 0 ;
98668
98669   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98670   {
98671     try {
98672       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
98673     } catch (std::out_of_range& e) {
98674       {
98675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98676       };
98677     } catch (std::exception& e) {
98678       {
98679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98680       };
98681     } catch (Dali::DaliException e) {
98682       {
98683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98684       };
98685     } catch (...) {
98686       {
98687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98688       };
98689     }
98690   }
98691
98692   jresult = (void *)result;
98693   return jresult;
98694 }
98695
98696
98697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
98698   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98699
98700   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98701   {
98702     try {
98703       (*arg1)->DisableDomain();
98704     } catch (std::out_of_range& e) {
98705       {
98706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98707       };
98708     } catch (std::exception& e) {
98709       {
98710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98711       };
98712     } catch (Dali::DaliException e) {
98713       {
98714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98715       };
98716     } catch (...) {
98717       {
98718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98719       };
98720     }
98721   }
98722
98723 }
98724
98725
98726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
98727   float jresult ;
98728   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98729   float arg2 ;
98730   float arg3 ;
98731   float arg4 ;
98732   float result;
98733
98734   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98735   arg2 = (float)jarg2;
98736   arg3 = (float)jarg3;
98737   arg4 = (float)jarg4;
98738   {
98739     try {
98740       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
98741     } catch (std::out_of_range& e) {
98742       {
98743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98744       };
98745     } catch (std::exception& e) {
98746       {
98747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98748       };
98749     } catch (Dali::DaliException e) {
98750       {
98751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98752       };
98753     } catch (...) {
98754       {
98755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98756       };
98757     }
98758   }
98759
98760   jresult = result;
98761   return jresult;
98762 }
98763
98764
98765 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
98766   float jresult ;
98767   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98768   float arg2 ;
98769   float arg3 ;
98770   float result;
98771
98772   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98773   arg2 = (float)jarg2;
98774   arg3 = (float)jarg3;
98775   {
98776     try {
98777       result = (float)(*arg1)->Clamp(arg2,arg3);
98778     } catch (std::out_of_range& e) {
98779       {
98780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98781       };
98782     } catch (std::exception& e) {
98783       {
98784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98785       };
98786     } catch (Dali::DaliException e) {
98787       {
98788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98789       };
98790     } catch (...) {
98791       {
98792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98793       };
98794     }
98795   }
98796
98797   jresult = result;
98798   return jresult;
98799 }
98800
98801
98802 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
98803   float jresult ;
98804   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98805   float arg2 ;
98806   float result;
98807
98808   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98809   arg2 = (float)jarg2;
98810   {
98811     try {
98812       result = (float)(*arg1)->Clamp(arg2);
98813     } catch (std::out_of_range& e) {
98814       {
98815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98816       };
98817     } catch (std::exception& e) {
98818       {
98819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98820       };
98821     } catch (Dali::DaliException e) {
98822       {
98823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98824       };
98825     } catch (...) {
98826       {
98827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98828       };
98829     }
98830   }
98831
98832   jresult = result;
98833   return jresult;
98834 }
98835
98836
98837 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
98838   float jresult ;
98839   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98840   float arg2 ;
98841   float arg3 ;
98842   float arg4 ;
98843   Dali::Toolkit::ClampState *arg5 = 0 ;
98844   float result;
98845
98846   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98847   arg2 = (float)jarg2;
98848   arg3 = (float)jarg3;
98849   arg4 = (float)jarg4;
98850   arg5 = (Dali::Toolkit::ClampState *)jarg5;
98851   if (!arg5) {
98852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
98853     return 0;
98854   }
98855   {
98856     try {
98857       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
98858     } catch (std::out_of_range& e) {
98859       {
98860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98861       };
98862     } catch (std::exception& e) {
98863       {
98864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98865       };
98866     } catch (Dali::DaliException e) {
98867       {
98868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98869       };
98870     } catch (...) {
98871       {
98872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98873       };
98874     }
98875   }
98876
98877   jresult = result;
98878   return jresult;
98879 }
98880
98881
98882 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
98883   float jresult ;
98884   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98885   float arg2 ;
98886   float arg3 ;
98887   float arg4 ;
98888   float arg5 ;
98889   float result;
98890
98891   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98892   arg2 = (float)jarg2;
98893   arg3 = (float)jarg3;
98894   arg4 = (float)jarg4;
98895   arg5 = (float)jarg5;
98896   {
98897     try {
98898       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
98899     } catch (std::out_of_range& e) {
98900       {
98901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98902       };
98903     } catch (std::exception& e) {
98904       {
98905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98906       };
98907     } catch (Dali::DaliException e) {
98908       {
98909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98910       };
98911     } catch (...) {
98912       {
98913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98914       };
98915     }
98916   }
98917
98918   jresult = result;
98919   return jresult;
98920 }
98921
98922
98923 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
98924   float jresult ;
98925   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98926   float arg2 ;
98927   float arg3 ;
98928   float arg4 ;
98929   float result;
98930
98931   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98932   arg2 = (float)jarg2;
98933   arg3 = (float)jarg3;
98934   arg4 = (float)jarg4;
98935   {
98936     try {
98937       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
98938     } catch (std::out_of_range& e) {
98939       {
98940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98941       };
98942     } catch (std::exception& e) {
98943       {
98944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98945       };
98946     } catch (Dali::DaliException e) {
98947       {
98948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98949       };
98950     } catch (...) {
98951       {
98952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98953       };
98954     }
98955   }
98956
98957   jresult = result;
98958   return jresult;
98959 }
98960
98961
98962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
98963   float jresult ;
98964   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98965   float arg2 ;
98966   float arg3 ;
98967   float result;
98968
98969   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98970   arg2 = (float)jarg2;
98971   arg3 = (float)jarg3;
98972   {
98973     try {
98974       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
98975     } catch (std::out_of_range& e) {
98976       {
98977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98978       };
98979     } catch (std::exception& e) {
98980       {
98981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98982       };
98983     } catch (Dali::DaliException e) {
98984       {
98985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98986       };
98987     } catch (...) {
98988       {
98989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98990       };
98991     }
98992   }
98993
98994   jresult = result;
98995   return jresult;
98996 }
98997
98998
98999 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
99000   float jresult ;
99001   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99002   float arg2 ;
99003   float result;
99004
99005   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99006   arg2 = (float)jarg2;
99007   {
99008     try {
99009       result = (float)(*arg1)->SnapAndClamp(arg2);
99010     } catch (std::out_of_range& e) {
99011       {
99012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99013       };
99014     } catch (std::exception& e) {
99015       {
99016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99017       };
99018     } catch (Dali::DaliException e) {
99019       {
99020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99021       };
99022     } catch (...) {
99023       {
99024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99025       };
99026     }
99027   }
99028
99029   jresult = result;
99030   return jresult;
99031 }
99032
99033
99034 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
99035   float jresult ;
99036   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99037   float arg2 ;
99038   float arg3 ;
99039   float arg4 ;
99040   float arg5 ;
99041   Dali::Toolkit::ClampState *arg6 = 0 ;
99042   float result;
99043
99044   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99045   arg2 = (float)jarg2;
99046   arg3 = (float)jarg3;
99047   arg4 = (float)jarg4;
99048   arg5 = (float)jarg5;
99049   arg6 = (Dali::Toolkit::ClampState *)jarg6;
99050   if (!arg6) {
99051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99052     return 0;
99053   }
99054   {
99055     try {
99056       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
99057     } catch (std::out_of_range& e) {
99058       {
99059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99060       };
99061     } catch (std::exception& e) {
99062       {
99063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99064       };
99065     } catch (Dali::DaliException e) {
99066       {
99067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99068       };
99069     } catch (...) {
99070       {
99071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99072       };
99073     }
99074   }
99075
99076   jresult = result;
99077   return jresult;
99078 }
99079
99080
99081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
99082   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99083
99084   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99085   {
99086     try {
99087       (*arg1)->Reference();
99088     } catch (std::out_of_range& e) {
99089       {
99090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99091       };
99092     } catch (std::exception& e) {
99093       {
99094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99095       };
99096     } catch (Dali::DaliException e) {
99097       {
99098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99099       };
99100     } catch (...) {
99101       {
99102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99103       };
99104     }
99105   }
99106
99107 }
99108
99109
99110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
99111   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99112
99113   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99114   {
99115     try {
99116       (*arg1)->Unreference();
99117     } catch (std::out_of_range& e) {
99118       {
99119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99120       };
99121     } catch (std::exception& e) {
99122       {
99123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99124       };
99125     } catch (Dali::DaliException e) {
99126       {
99127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99128       };
99129     } catch (...) {
99130       {
99131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99132       };
99133     }
99134   }
99135
99136 }
99137
99138
99139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
99140   int jresult ;
99141   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99142   int result;
99143
99144   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99145   {
99146     try {
99147       result = (int)(*arg1)->ReferenceCount();
99148     } catch (std::out_of_range& e) {
99149       {
99150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99151       };
99152     } catch (std::exception& e) {
99153       {
99154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99155       };
99156     } catch (Dali::DaliException e) {
99157       {
99158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99159       };
99160     } catch (...) {
99161       {
99162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99163       };
99164     }
99165   }
99166
99167   jresult = result;
99168   return jresult;
99169 }
99170
99171
99172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
99173   unsigned int jresult ;
99174   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99175   bool result;
99176
99177   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99178   {
99179     try {
99180       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99181     } catch (std::out_of_range& e) {
99182       {
99183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99184       };
99185     } catch (std::exception& e) {
99186       {
99187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99188       };
99189     } catch (Dali::DaliException e) {
99190       {
99191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99192       };
99193     } catch (...) {
99194       {
99195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99196       };
99197     }
99198   }
99199
99200   jresult = result;
99201   return jresult;
99202 }
99203
99204
99205 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
99206   unsigned long jresult ;
99207   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99208   std::size_t result;
99209
99210   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99211   {
99212     try {
99213       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99214     } catch (std::out_of_range& e) {
99215       {
99216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99217       };
99218     } catch (std::exception& e) {
99219       {
99220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99221       };
99222     } catch (Dali::DaliException e) {
99223       {
99224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99225       };
99226     } catch (...) {
99227       {
99228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99229       };
99230     }
99231   }
99232
99233   jresult = (unsigned long)result;
99234   return jresult;
99235 }
99236
99237
99238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
99239   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99240   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99241
99242   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99243   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99244   {
99245     try {
99246       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
99247     } catch (std::out_of_range& e) {
99248       {
99249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99250       };
99251     } catch (std::exception& e) {
99252       {
99253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99254       };
99255     } catch (Dali::DaliException e) {
99256       {
99257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99258       };
99259     } catch (...) {
99260       {
99261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99262       };
99263     }
99264   }
99265
99266 }
99267
99268
99269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
99270   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99271   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99272
99273   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99274   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99275   {
99276     try {
99277       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
99278     } catch (std::out_of_range& e) {
99279       {
99280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99281       };
99282     } catch (std::exception& e) {
99283       {
99284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99285       };
99286     } catch (Dali::DaliException e) {
99287       {
99288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99289       };
99290     } catch (...) {
99291       {
99292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99293       };
99294     }
99295   }
99296
99297 }
99298
99299
99300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
99301   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99302   Dali::Toolkit::Control arg2 ;
99303   Dali::Toolkit::Control *argp2 ;
99304
99305   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99306   argp2 = (Dali::Toolkit::Control *)jarg2;
99307   if (!argp2) {
99308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
99309     return ;
99310   }
99311   arg2 = *argp2;
99312   {
99313     try {
99314       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
99315     } catch (std::out_of_range& e) {
99316       {
99317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99318       };
99319     } catch (std::exception& e) {
99320       {
99321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99322       };
99323     } catch (Dali::DaliException e) {
99324       {
99325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99326       };
99327     } catch (...) {
99328       {
99329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99330       };
99331     }
99332   }
99333
99334 }
99335
99336
99337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
99338   void * jresult ;
99339   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
99340
99341   {
99342     try {
99343       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
99344     } catch (std::out_of_range& e) {
99345       {
99346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99347       };
99348     } catch (std::exception& e) {
99349       {
99350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99351       };
99352     } catch (Dali::DaliException e) {
99353       {
99354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99355       };
99356     } catch (...) {
99357       {
99358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99359       };
99360     }
99361   }
99362
99363   jresult = (void *)result;
99364   return jresult;
99365 }
99366
99367
99368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
99369   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99370
99371   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99372   {
99373     try {
99374       delete arg1;
99375     } catch (std::out_of_range& e) {
99376       {
99377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99378       };
99379     } catch (std::exception& e) {
99380       {
99381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99382       };
99383     } catch (Dali::DaliException e) {
99384       {
99385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99386       };
99387     } catch (...) {
99388       {
99389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99390       };
99391     }
99392   }
99393
99394 }
99395
99396 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
99397   Dali::RefObject *result = NULL;
99398
99399   if (arg1)
99400   {
99401     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
99402   }
99403   return result;
99404 }
99405
99406 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
99407     return (Dali::RefObject *)jarg1;
99408 }
99409
99410 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
99411     return (Dali::SignalObserver *)jarg1;
99412 }
99413
99414 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
99415     return (Dali::ConnectionTrackerInterface *)jarg1;
99416 }
99417
99418 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
99419     return (Dali::BaseHandle *)jarg1;
99420 }
99421
99422 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
99423     return (Dali::BaseHandle *)jarg1;
99424 }
99425
99426 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
99427     return (Dali::BaseHandle *)jarg1;
99428 }
99429
99430 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
99431     return (Dali::BaseHandle *)jarg1;
99432 }
99433
99434 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
99435     return (Dali::BaseHandle *)jarg1;
99436 }
99437
99438 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
99439     return (Dali::BaseHandle *)jarg1;
99440 }
99441
99442 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
99443     return (Dali::BaseHandle *)jarg1;
99444 }
99445
99446 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
99447     return (Dali::BaseHandle *)jarg1;
99448 }
99449
99450 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
99451     return (Dali::BaseHandle *)jarg1;
99452 }
99453
99454 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
99455     return (Dali::BaseHandle *)jarg1;
99456 }
99457
99458 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
99459     return (Dali::BaseHandle *)jarg1;
99460 }
99461
99462 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
99463     return (Dali::BaseHandle *)jarg1;
99464 }
99465
99466 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
99467     return (Dali::BaseHandle *)jarg1;
99468 }
99469
99470 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
99471     return (Dali::Handle *)jarg1;
99472 }
99473
99474 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
99475     return (Dali::Handle *)jarg1;
99476 }
99477
99478 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
99479     return (Dali::BaseHandle *)jarg1;
99480 }
99481
99482 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
99483     return (Dali::BaseHandle *)jarg1;
99484 }
99485
99486 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
99487     return (Dali::Handle *)jarg1;
99488 }
99489
99490 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
99491     return (Dali::BaseHandle *)jarg1;
99492 }
99493
99494 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
99495     return (Dali::Handle *)jarg1;
99496 }
99497
99498 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
99499     return (Dali::GestureDetector *)jarg1;
99500 }
99501
99502 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
99503     return (Dali::Gesture *)jarg1;
99504 }
99505
99506 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
99507     return (Dali::Handle *)jarg1;
99508 }
99509
99510 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
99511     return (Dali::Actor *)jarg1;
99512 }
99513
99514 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
99515     return (Dali::BaseHandle *)jarg1;
99516 }
99517
99518 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
99519     return (Dali::RefObject *)jarg1;
99520 }
99521
99522 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
99523     return (Dali::Actor *)jarg1;
99524 }
99525
99526 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
99527     return (Dali::GestureDetector *)jarg1;
99528 }
99529
99530 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
99531     return (Dali::Gesture *)jarg1;
99532 }
99533
99534 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
99535     return (Dali::GestureDetector *)jarg1;
99536 }
99537
99538 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
99539     return (Dali::Gesture *)jarg1;
99540 }
99541
99542 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
99543     return (Dali::GestureDetector *)jarg1;
99544 }
99545
99546 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
99547     return (Dali::Gesture *)jarg1;
99548 }
99549
99550 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
99551     return (Dali::BaseHandle *)jarg1;
99552 }
99553
99554 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
99555     return (Dali::Handle *)jarg1;
99556 }
99557
99558 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
99559     return (Dali::Handle *)jarg1;
99560 }
99561
99562 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
99563     return (Dali::Handle *)jarg1;
99564 }
99565
99566 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
99567     return (Dali::Image *)jarg1;
99568 }
99569
99570 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
99571     return (Dali::Image *)jarg1;
99572 }
99573
99574 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
99575     return (Dali::Image *)jarg1;
99576 }
99577
99578 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
99579     return (Dali::RefObject *)jarg1;
99580 }
99581
99582 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
99583     return (Dali::Image *)jarg1;
99584 }
99585
99586 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
99587     return (Dali::Image *)jarg1;
99588 }
99589
99590 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
99591     return (Dali::ResourceImage *)jarg1;
99592 }
99593
99594 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
99595     return (Dali::Actor *)jarg1;
99596 }
99597
99598 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
99599     return (Dali::BaseHandle *)jarg1;
99600 }
99601
99602 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
99603     return (Dali::BaseHandle *)jarg1;
99604 }
99605
99606 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
99607     return (Dali::BaseHandle *)jarg1;
99608 }
99609
99610 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
99611     return (Dali::CustomActorImpl *)jarg1;
99612 }
99613
99614 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
99615     return (Dali::CustomActor *)jarg1;
99616 }
99617
99618 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
99619     return (Dali::BaseHandle *)jarg1;
99620 }
99621
99622 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
99623     return (Dali::Toolkit::Control *)jarg1;
99624 }
99625
99626 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
99627     return (Dali::Toolkit::Control *)jarg1;
99628 }
99629
99630 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
99631     return (Dali::Toolkit::Button *)jarg1;
99632 }
99633
99634 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
99635     return (Dali::Toolkit::Button *)jarg1;
99636 }
99637
99638 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
99639     return (Dali::Toolkit::Button *)jarg1;
99640 }
99641
99642 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
99643     return (Dali::Toolkit::Control *)jarg1;
99644 }
99645
99646 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
99647     return (Dali::Toolkit::Control *)jarg1;
99648 }
99649
99650 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
99651     return (Dali::Toolkit::Control *)jarg1;
99652 }
99653
99654 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
99655     return (Dali::Toolkit::Control *)jarg1;
99656 }
99657
99658 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
99659     return (Dali::Toolkit::Control *)jarg1;
99660 }
99661
99662 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
99663     return (Dali::RefObject *)jarg1;
99664 }
99665
99666 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
99667     return (Dali::Toolkit::Scrollable *)jarg1;
99668 }
99669
99670 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
99671     return (Dali::BaseHandle *)jarg1;
99672 }
99673
99674 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
99675     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
99676 }
99677
99678 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
99679     return (Dali::RefObject *)jarg1;
99680 }
99681
99682 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
99683     return (Dali::Toolkit::Ruler *)jarg1;
99684 }
99685
99686 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
99687     return (Dali::Toolkit::Ruler *)jarg1;
99688 }
99689
99690 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
99691     return (Dali::Toolkit::Scrollable *)jarg1;
99692 }
99693
99694 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
99695     return (Dali::Toolkit::Control *)jarg1;
99696 }
99697
99698
99699 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
99700     return (Dali::Toolkit::Control *)jarg1;
99701 }
99702
99703 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
99704     return (Dali::BaseHandle *)jarg1;
99705 }
99706
99707 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
99708     return (Dali::BaseHandle *)jarg1;
99709 }
99710
99711 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
99712     return (Dali::Toolkit::Control *)jarg1;
99713 }
99714
99715 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
99716     return (Dali::Toolkit::Control *)jarg1;
99717 }
99718
99719 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
99720     return (Dali::Toolkit::Control *)jarg1;
99721 }
99722
99723 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
99724     return (Dali::Toolkit::Control *)jarg1;
99725 }
99726
99727 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
99728     return (Dali::Toolkit::Control *)jarg1;
99729 }
99730
99731 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
99732     return (Dali::Toolkit::Control *)jarg1;
99733 }
99734
99735 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
99736     return (Dali::Toolkit::PageTurnView *)jarg1;
99737 }
99738
99739 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
99740     return (Dali::Toolkit::PageTurnView *)jarg1;
99741 }
99742
99743 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
99744     return (Dali::Toolkit::Button *)jarg1;
99745 }
99746
99747 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
99748     return (Dali::BaseHandle *)jarg1;
99749 }
99750
99751 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
99752     return (Dali::BaseHandle *)jarg1;
99753 }
99754
99755 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
99756     return (Dali::BaseHandle *)jarg1;
99757 }
99758
99759 /*
99760  * Widget binding
99761  */
99762 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
99763     return (Dali::BaseHandle *)jarg1;
99764 }
99765
99766 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
99767     return (Dali::BaseObject *)jarg1;
99768 }
99769
99770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
99771   void * jresult ;
99772   Dali::Widget result;
99773
99774   {
99775     try {
99776       result = Dali::Widget::New();
99777     } catch (std::out_of_range& e) {
99778       {
99779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99780       };
99781     } catch (std::exception& e) {
99782       {
99783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99784       };
99785     } catch (...) {
99786       {
99787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99788       };
99789     }
99790   }
99791   jresult = new Dali::Widget((const Dali::Widget &)result);
99792   return jresult;
99793 }
99794
99795
99796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
99797   void * jresult ;
99798   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
99799   Dali::Widget result;
99800
99801   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99802
99803   if (!arg1) {
99804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
99805     return 0;
99806   }
99807   {
99808     try {
99809       jresult = new Dali::Widget(arg1);
99810     } catch (std::out_of_range& e) {
99811       {
99812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99813       };
99814     } catch (std::exception& e) {
99815       {
99816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99817       };
99818     } catch (...) {
99819       {
99820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99821       };
99822     }
99823   }
99824   return jresult;
99825 }
99826
99827
99828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
99829   void * jresult ;
99830   Dali::Widget *result = 0 ;
99831
99832   {
99833     try {
99834       result = (Dali::Widget *)new Dali::Widget();
99835     } catch (std::out_of_range& e) {
99836       {
99837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99838       };
99839     } catch (std::exception& e) {
99840       {
99841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99842       };
99843     } catch (...) {
99844       {
99845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99846       };
99847     }
99848   }
99849   jresult = (void *)result;
99850   return jresult;
99851 }
99852
99853
99854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
99855   void * jresult ;
99856   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
99857   Dali::Widget *arg2 = 0 ;
99858   Dali::Widget *result = 0 ;
99859
99860   arg1 = (Dali::Widget *)jarg1;
99861   arg2 = (Dali::Widget *)jarg2;
99862   if (!arg2) {
99863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
99864     return 0;
99865   }
99866   {
99867     try {
99868       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
99869     } catch (std::out_of_range& e) {
99870       {
99871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99872       };
99873     } catch (std::exception& e) {
99874       {
99875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99876       };
99877     } catch (...) {
99878       {
99879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99880       };
99881     }
99882   }
99883   jresult = (void *)result;
99884   return jresult;
99885 }
99886
99887
99888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
99889   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
99890
99891   arg1 = (Dali::Widget *)jarg1;
99892   {
99893     try {
99894       delete arg1;
99895     } catch (std::out_of_range& e) {
99896       {
99897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99898       };
99899     } catch (std::exception& e) {
99900       {
99901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99902       };
99903     } catch (...) {
99904       {
99905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99906       };
99907     }
99908   }
99909 }
99910
99911
99912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
99913   void * jresult ;
99914   SwigDirector_WidgetImpl* result;
99915   {
99916     try {
99917       result = new SwigDirector_WidgetImpl();
99918     } catch (std::out_of_range& e) {
99919       {
99920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99921       };
99922     } catch (std::exception& e) {
99923       {
99924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99925       };
99926     } catch (...) {
99927       {
99928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99929       };
99930     }
99931   }
99932   jresult = result;
99933   return jresult;
99934 }
99935
99936
99937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
99938   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99939   std::string *arg2 = 0 ;
99940   Dali::Window arg3 ;
99941   Dali::Window *argp3 ;
99942
99943   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99944   if (!jarg2) {
99945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99946     return ;
99947   }
99948   std::string arg2_str(jarg2);
99949   arg2 = &arg2_str;
99950   argp3 = (Dali::Window *)jarg3;
99951   if (!argp3) {
99952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
99953     return ;
99954   }
99955   arg3 = *argp3;
99956   {
99957     try {
99958       (arg1)->OnCreate((std::string const &)*arg2,arg3);
99959     } catch (std::out_of_range& e) {
99960       {
99961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99962       };
99963     } catch (std::exception& e) {
99964       {
99965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99966       };
99967     } catch (...) {
99968       {
99969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99970       };
99971     }
99972   }
99973 }
99974
99975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
99976   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99977   std::string *arg2 = 0 ;
99978   Dali::Window arg3 ;
99979   Dali::Window *argp3 ;
99980
99981   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99982   if (!jarg2) {
99983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99984     return ;
99985   }
99986   std::string arg2_str(jarg2);
99987   arg2 = &arg2_str;
99988   argp3 = (Dali::Window *)jarg3;
99989   if (!argp3) {
99990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
99991     return ;
99992   }
99993   arg3 = *argp3;
99994   {
99995     try {
99996       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
99997     } catch (std::out_of_range& e) {
99998       {
99999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100000       };
100001     } catch (std::exception& e) {
100002       {
100003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100004       };
100005     } catch (...) {
100006       {
100007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100008       };
100009     }
100010   }
100011 }
100012
100013
100014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
100015   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100016   std::string *arg2 = 0 ;
100017   Dali::Widget::Termination arg3 ;
100018
100019   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100020   if (!jarg2) {
100021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100022     return ;
100023   }
100024   std::string arg2_str(jarg2);
100025   arg2 = &arg2_str;
100026   arg3 = (Dali::Widget::Termination)jarg3;
100027   {
100028     try {
100029       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
100030     } catch (std::out_of_range& e) {
100031       {
100032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100033       };
100034     } catch (std::exception& e) {
100035       {
100036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100037       };
100038     } catch (...) {
100039       {
100040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100041       };
100042     }
100043   }
100044 }
100045
100046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100047   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100048   std::string *arg2 = 0 ;
100049   Dali::Widget::Termination arg3 ;
100050
100051   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100052   if (!jarg2) {
100053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100054     return ;
100055   }
100056   std::string arg2_str(jarg2);
100057   arg2 = &arg2_str;
100058   arg3 = (Dali::Widget::Termination)jarg3;
100059   {
100060     try {
100061       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
100062     } catch (std::out_of_range& e) {
100063       {
100064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100065       };
100066     } catch (std::exception& e) {
100067       {
100068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100069       };
100070     } catch (...) {
100071       {
100072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100073       };
100074     }
100075   }
100076 }
100077
100078
100079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
100080   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100081
100082   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100083   {
100084     try {
100085       (arg1)->OnPause();
100086     } catch (std::out_of_range& e) {
100087       {
100088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100089       };
100090     } catch (std::exception& e) {
100091       {
100092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100093       };
100094     } catch (...) {
100095       {
100096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100097       };
100098     }
100099   }
100100 }
100101
100102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
100103   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100104
100105   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100106   {
100107     try {
100108       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
100109     } catch (std::out_of_range& e) {
100110       {
100111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100112       };
100113     } catch (std::exception& e) {
100114       {
100115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100116       };
100117     } catch (...) {
100118       {
100119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100120       };
100121     }
100122   }
100123 }
100124
100125
100126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
100127   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100128
100129   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100130   {
100131     try {
100132       (arg1)->OnResume();
100133     } catch (std::out_of_range& e) {
100134       {
100135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100136       };
100137     } catch (std::exception& e) {
100138       {
100139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100140       };
100141     } catch (...) {
100142       {
100143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100144       };
100145     }
100146   }
100147 }
100148
100149
100150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
100151   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100152
100153   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100154   {
100155     try {
100156       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
100157     } catch (std::out_of_range& e) {
100158       {
100159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100160       };
100161     } catch (std::exception& e) {
100162       {
100163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100164       };
100165     } catch (...) {
100166       {
100167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100168       };
100169     }
100170   }
100171 }
100172
100173
100174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
100175   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100176   Dali::Window arg2 ;
100177   Dali::Window *argp2 ;
100178
100179   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100180   argp2 = (Dali::Window *)jarg2;
100181   if (!argp2) {
100182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100183     return ;
100184   }
100185   arg2 = *argp2;
100186   {
100187     try {
100188       (arg1)->OnResize(arg2);
100189     } catch (std::out_of_range& e) {
100190       {
100191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100192       };
100193     } catch (std::exception& e) {
100194       {
100195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100196       };
100197     } catch (...) {
100198       {
100199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100200       };
100201     }
100202   }
100203 }
100204
100205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
100206   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100207   Dali::Window arg2 ;
100208   Dali::Window *argp2 ;
100209
100210   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100211   argp2 = (Dali::Window *)jarg2;
100212   if (!argp2) {
100213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100214     return ;
100215   }
100216   arg2 = *argp2;
100217   {
100218     try {
100219       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
100220     } catch (std::out_of_range& e) {
100221       {
100222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100223       };
100224     } catch (std::exception& e) {
100225       {
100226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100227       };
100228     } catch (...) {
100229       {
100230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100231       };
100232     }
100233   }
100234 }
100235
100236
100237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
100238   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100239   std::string *arg2 = 0 ;
100240   int arg3 ;
100241
100242   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100243   if (!jarg2) {
100244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100245     return ;
100246   }
100247   std::string arg2_str(jarg2);
100248   arg2 = &arg2_str;
100249   arg3 = (int)jarg3;
100250   {
100251     try {
100252       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
100253     } catch (std::out_of_range& e) {
100254       {
100255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100256       };
100257     } catch (std::exception& e) {
100258       {
100259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100260       };
100261     } catch (...) {
100262       {
100263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100264       };
100265     }
100266   }
100267 }
100268
100269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100270   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100271   std::string *arg2 = 0 ;
100272   int arg3 ;
100273
100274   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100275   if (!jarg2) {
100276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100277     return ;
100278   }
100279   std::string arg2_str(jarg2);
100280   arg2 = &arg2_str;
100281   arg3 = (int)jarg3;
100282   {
100283     try {
100284       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
100285     } catch (std::out_of_range& e) {
100286       {
100287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100288       };
100289     } catch (std::exception& e) {
100290       {
100291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100292       };
100293     } catch (...) {
100294       {
100295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100296       };
100297     }
100298   }
100299 }
100300
100301
100302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
100303   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100304   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100305   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100306
100307   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100308   arg2 = (Dali::SlotObserver *)jarg2;
100309   arg3 = (Dali::CallbackBase *)jarg3;
100310   {
100311     try {
100312       (arg1)->SignalConnected(arg2,arg3);
100313     } catch (std::out_of_range& e) {
100314       {
100315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100316       };
100317     } catch (std::exception& e) {
100318       {
100319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100320       };
100321     } catch (...) {
100322       {
100323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100324       };
100325     }
100326   }
100327 }
100328
100329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100330   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100331   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100332   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100333
100334   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100335   arg2 = (Dali::SlotObserver *)jarg2;
100336   arg3 = (Dali::CallbackBase *)jarg3;
100337   {
100338     try {
100339       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
100340     } catch (std::out_of_range& e) {
100341       {
100342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100343       };
100344     } catch (std::exception& e) {
100345       {
100346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100347       };
100348     } catch (...) {
100349       {
100350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100351       };
100352     }
100353   }
100354 }
100355
100356
100357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
100358   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100359   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100360   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100361
100362   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100363   arg2 = (Dali::SlotObserver *)jarg2;
100364   arg3 = (Dali::CallbackBase *)jarg3;
100365   {
100366     try {
100367       (arg1)->SignalDisconnected(arg2,arg3);
100368     } catch (std::out_of_range& e) {
100369       {
100370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100371       };
100372     } catch (std::exception& e) {
100373       {
100374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100375       };
100376     } catch (...) {
100377       {
100378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100379       };
100380     }
100381   }
100382 }
100383
100384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100385   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100386   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100387   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100388
100389   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100390   arg2 = (Dali::SlotObserver *)jarg2;
100391   arg3 = (Dali::CallbackBase *)jarg3;
100392   {
100393     try {
100394       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
100395     } catch (std::out_of_range& e) {
100396       {
100397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100398       };
100399     } catch (std::exception& e) {
100400       {
100401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100402       };
100403     } catch (...) {
100404       {
100405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100406       };
100407     }
100408   }
100409 }
100410
100411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
100412   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100413   std::string *arg2 = 0 ;
100414
100415   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100416   if (!jarg2) {
100417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100418     return ;
100419   }
100420   std::string arg2_str(jarg2);
100421   arg2 = &arg2_str;
100422   {
100423     try {
100424       (arg1)->SetContentInfo((std::string const &)*arg2);
100425     } catch (std::out_of_range& e) {
100426       {
100427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100428       };
100429     } catch (std::exception& e) {
100430       {
100431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100432       };
100433     } catch (...) {
100434       {
100435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100436       };
100437     }
100438   }
100439 }
100440
100441
100442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
100443   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100444   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
100445
100446   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100447   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
100448   {
100449     try {
100450       (arg1)->SetImpl(arg2);
100451     } catch (std::out_of_range& e) {
100452       {
100453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100454       };
100455     } catch (std::exception& e) {
100456       {
100457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100458       };
100459     } catch (...) {
100460       {
100461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100462       };
100463     }
100464   }
100465 }
100466
100467 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) {
100468
100469   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
100470   if (director) {
100471     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
100472   }
100473 }
100474
100475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
100476   void * jresult ;
100477   Dali::Widget *arg1 = 0 ;
100478   SwigDirector_WidgetImpl *result = 0 ;
100479
100480   arg1 = (Dali::Widget *)jarg1;
100481   if (!arg1) {
100482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
100483     return 0;
100484   }
100485   {
100486     try {
100487       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
100488     } catch (std::out_of_range& e) {
100489       {
100490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100491       };
100492     } catch (std::exception& e) {
100493       {
100494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100495       };
100496     } catch (...) {
100497       {
100498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100499       };
100500     }
100501   }
100502
100503   jresult = (void *)result;
100504   return jresult;
100505 }
100506
100507
100508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
100509   void * jresult ;
100510   int *arg1 = (int *) 0 ;
100511   char ***arg2 ;
100512   std::string *arg3 = 0 ;
100513   Dali::WidgetApplication result;
100514   {
100515     int index = 0;
100516     int length = 0;
100517     char *retPtr;
100518     char *nextPtr;
100519     argWidgetC = jarg1;
100520     argWidgetV = new char*[jarg1 + 1];
100521
100522     retPtr = strtok_r( jarg2, " ", &nextPtr);
100523     if( retPtr )
100524     {
100525       length = strlen(retPtr);
100526     }
100527     argWidgetV[index] = new char[length + 1];
100528     if( retPtr )
100529     {
100530       strncpy(argWidgetV[index], retPtr, length);
100531     }
100532     argWidgetV[index][length] = '\0';
100533     index++;
100534
100535     while (index < jarg1)
100536     {
100537       length = 0;
100538       retPtr = strtok_r(NULL, " ", &nextPtr);
100539       if( retPtr )
100540       {
100541         length = strlen(retPtr);
100542       }
100543       argWidgetV[index] = new char[length + 1];
100544       if( retPtr )
100545       {
100546         strncpy(argWidgetV[index], retPtr, length);
100547       }
100548       argWidgetV[index][length] = '\0';
100549       index++;
100550     }
100551
100552     argWidgetV[jarg1] = NULL;
100553     argWidgetC = jarg1;
100554
100555     arg1 = &argWidgetC;
100556     arg2 = &argWidgetV;
100557   }
100558
100559   if (!jarg3) {
100560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100561     return 0;
100562   }
100563   std::string arg3_str(jarg3);
100564   arg3 = &arg3_str;
100565   {
100566     try {
100567       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
100568     } catch (std::out_of_range& e) {
100569       {
100570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100571       };
100572     } catch (std::exception& e) {
100573       {
100574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100575       };
100576     } catch (...) {
100577       {
100578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100579       };
100580     }
100581   }
100582   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
100583
100584   return jresult;
100585 }
100586
100587
100588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
100589   void * jresult ;
100590   Dali::WidgetApplication *result = 0 ;
100591
100592   {
100593     try {
100594       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
100595     } catch (std::out_of_range& e) {
100596       {
100597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100598       };
100599     } catch (std::exception& e) {
100600       {
100601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100602       };
100603     } catch (...) {
100604       {
100605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100606       };
100607     }
100608   }
100609   jresult = (void *)result;
100610   return jresult;
100611 }
100612
100613
100614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
100615   void * jresult ;
100616   Dali::WidgetApplication *arg1 = 0 ;
100617   Dali::WidgetApplication *result = 0 ;
100618
100619   arg1 = (Dali::WidgetApplication *)jarg1;
100620   if (!arg1) {
100621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100622     return 0;
100623   }
100624   {
100625     try {
100626       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
100627     } catch (std::out_of_range& e) {
100628       {
100629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100630       };
100631     } catch (std::exception& e) {
100632       {
100633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100634       };
100635     } catch (...) {
100636       {
100637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100638       };
100639     }
100640   }
100641   jresult = (void *)result;
100642   return jresult;
100643 }
100644
100645
100646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
100647   void * jresult ;
100648   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100649   Dali::WidgetApplication *arg2 = 0 ;
100650   Dali::WidgetApplication *result = 0 ;
100651
100652   arg1 = (Dali::WidgetApplication *)jarg1;
100653   arg2 = (Dali::WidgetApplication *)jarg2;
100654   if (!arg2) {
100655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100656     return 0;
100657   }
100658   {
100659     try {
100660       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
100661     } catch (std::out_of_range& e) {
100662       {
100663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100664       };
100665     } catch (std::exception& e) {
100666       {
100667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100668       };
100669     } catch (...) {
100670       {
100671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100672       };
100673     }
100674   }
100675   jresult = (void *)result;
100676   return jresult;
100677 }
100678
100679
100680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
100681   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100682
100683   arg1 = (Dali::WidgetApplication *)jarg1;
100684   {
100685     try {
100686       delete arg1;
100687       if( argWidgetV )
100688       {
100689         // free string data
100690         for( int i=0; i < argWidgetC+1; i++)
100691         {
100692           delete [] argWidgetV[i];
100693         }
100694         delete [] argWidgetV;
100695       }
100696     } catch (std::out_of_range& e) {
100697       {
100698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100699       };
100700     } catch (std::exception& e) {
100701       {
100702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100703       };
100704     } catch (...) {
100705       {
100706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100707       };
100708     }
100709   }
100710 }
100711
100712
100713 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
100714 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
100715
100716 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
100717 {
100718   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
100719   return *widget;
100720 }
100721
100722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
100723   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100724   std::string *arg2 = 0 ;
100725
100726   arg1 = (Dali::WidgetApplication *)jarg1;
100727   if (!jarg2) {
100728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100729     return ;
100730   }
100731   std::string arg2_str(*jarg2);
100732   arg2 = &arg2_str;
100733
100734   if(!_CSharpCreateWidgetFunction)
100735   {
100736     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
100737   }
100738
100739   {
100740     try {
100741       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
100742     } catch (std::out_of_range& e) {
100743       {
100744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100745       };
100746     } catch (std::exception& e) {
100747       {
100748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100749       };
100750     } catch (...) {
100751       {
100752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100753       };
100754     }
100755   }
100756
100757   //Typemap argout in c++ file.
100758   //This will convert c++ string to c# string
100759   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
100760 }
100761
100762
100763 //for PixelBuffer and ImageLoading
100764
100765 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
100766     return (Dali::BaseHandle *)jarg1;
100767 }
100768
100769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
100770   void * jresult ;
100771   unsigned int arg1 ;
100772   unsigned int arg2 ;
100773   Dali::Pixel::Format arg3 ;
100774   Dali::Devel::PixelBuffer result;
100775
100776   arg1 = (unsigned int)jarg1;
100777   arg2 = (unsigned int)jarg2;
100778   arg3 = (Dali::Pixel::Format)jarg3;
100779   {
100780     try {
100781       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
100782     } catch (std::out_of_range& e) {
100783       {
100784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100785       };
100786     } catch (std::exception& e) {
100787       {
100788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100789       };
100790     } catch (...) {
100791       {
100792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100793       };
100794     }
100795   }
100796   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100797   return jresult;
100798 }
100799
100800
100801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
100802   void * jresult ;
100803   Dali::Devel::PixelBuffer *result = 0 ;
100804
100805   {
100806     try {
100807       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
100808     } catch (std::out_of_range& e) {
100809       {
100810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100811       };
100812     } catch (std::exception& e) {
100813       {
100814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100815       };
100816     } catch (...) {
100817       {
100818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100819       };
100820     }
100821   }
100822   jresult = (void *)result;
100823   return jresult;
100824 }
100825
100826
100827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
100828   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100829
100830   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100831   {
100832     try {
100833       delete arg1;
100834     } catch (std::out_of_range& e) {
100835       {
100836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100837       };
100838     } catch (std::exception& e) {
100839       {
100840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100841       };
100842     } catch (...) {
100843       {
100844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100845       };
100846     }
100847   }
100848 }
100849
100850
100851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
100852   void * jresult ;
100853   Dali::Devel::PixelBuffer *arg1 = 0 ;
100854   Dali::Devel::PixelBuffer *result = 0 ;
100855
100856   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100857   if (!arg1) {
100858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
100859     return 0;
100860   }
100861   {
100862     try {
100863       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
100864     } catch (std::out_of_range& e) {
100865       {
100866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100867       };
100868     } catch (std::exception& e) {
100869       {
100870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100871       };
100872     } catch (...) {
100873       {
100874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100875       };
100876     }
100877   }
100878   jresult = (void *)result;
100879   return jresult;
100880 }
100881
100882
100883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
100884   void * jresult ;
100885   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100886   Dali::Devel::PixelBuffer *arg2 = 0 ;
100887   Dali::Devel::PixelBuffer *result = 0 ;
100888
100889   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100890   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
100891   if (!arg2) {
100892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
100893     return 0;
100894   }
100895   {
100896     try {
100897       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
100898     } catch (std::out_of_range& e) {
100899       {
100900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100901       };
100902     } catch (std::exception& e) {
100903       {
100904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100905       };
100906     } catch (...) {
100907       {
100908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100909       };
100910     }
100911   }
100912   jresult = (void *)result;
100913   return jresult;
100914 }
100915
100916
100917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
100918   void * jresult ;
100919   Dali::Devel::PixelBuffer *arg1 = 0 ;
100920   Dali::PixelData result;
100921
100922   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100923   if (!arg1) {
100924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
100925     return 0;
100926   }
100927   {
100928     try {
100929       result = Dali::Devel::PixelBuffer::Convert(*arg1);
100930     } catch (std::out_of_range& e) {
100931       {
100932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100933       };
100934     } catch (std::exception& e) {
100935       {
100936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100937       };
100938     } catch (...) {
100939       {
100940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100941       };
100942     }
100943   }
100944   jresult = new Dali::PixelData((const Dali::PixelData &)result);
100945   return jresult;
100946 }
100947
100948
100949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
100950   void * jresult ;
100951   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100952   Dali::PixelData result;
100953
100954   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100955   {
100956     try {
100957       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
100958     } catch (std::out_of_range& e) {
100959       {
100960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100961       };
100962     } catch (std::exception& e) {
100963       {
100964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100965       };
100966     } catch (...) {
100967       {
100968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100969       };
100970     }
100971   }
100972   jresult = new Dali::PixelData((const Dali::PixelData &)result);
100973   return jresult;
100974 }
100975
100976
100977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
100978   void * jresult ;
100979   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100980   unsigned char *result = 0 ;
100981
100982   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100983   {
100984     try {
100985       result = (unsigned char *)(arg1)->GetBuffer();
100986     } catch (std::out_of_range& e) {
100987       {
100988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100989       };
100990     } catch (std::exception& e) {
100991       {
100992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100993       };
100994     } catch (...) {
100995       {
100996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100997       };
100998     }
100999   }
101000   jresult = (void *)result;
101001   return jresult;
101002 }
101003
101004
101005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
101006   unsigned int jresult ;
101007   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101008   unsigned int result;
101009
101010   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101011   {
101012     try {
101013       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
101014     } catch (std::out_of_range& e) {
101015       {
101016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101017       };
101018     } catch (std::exception& e) {
101019       {
101020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101021       };
101022     } catch (...) {
101023       {
101024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101025       };
101026     }
101027   }
101028   jresult = result;
101029   return jresult;
101030 }
101031
101032
101033 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
101034   unsigned int jresult ;
101035   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101036   unsigned int result;
101037
101038   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101039   {
101040     try {
101041       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
101042     } catch (std::out_of_range& e) {
101043       {
101044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101045       };
101046     } catch (std::exception& e) {
101047       {
101048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101049       };
101050     } catch (...) {
101051       {
101052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101053       };
101054     }
101055   }
101056   jresult = result;
101057   return jresult;
101058 }
101059
101060
101061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
101062   int jresult ;
101063   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101064   Dali::Pixel::Format result;
101065
101066   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101067   {
101068     try {
101069       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
101070     } catch (std::out_of_range& e) {
101071       {
101072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101073       };
101074     } catch (std::exception& e) {
101075       {
101076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101077       };
101078     } catch (...) {
101079       {
101080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101081       };
101082     }
101083   }
101084   jresult = (int)result;
101085   return jresult;
101086 }
101087
101088
101089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
101090   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101091   Dali::Devel::PixelBuffer arg2 ;
101092   float arg3 ;
101093   bool arg4 ;
101094   Dali::Devel::PixelBuffer *argp2 ;
101095
101096   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101097   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101098   if (!argp2) {
101099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101100     return ;
101101   }
101102   arg2 = *argp2;
101103   arg3 = (float)jarg3;
101104   arg4 = jarg4 ? true : false;
101105   {
101106     try {
101107       (arg1)->ApplyMask(arg2,arg3,arg4);
101108     } catch (std::out_of_range& e) {
101109       {
101110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101111       };
101112     } catch (std::exception& e) {
101113       {
101114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101115       };
101116     } catch (...) {
101117       {
101118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101119       };
101120     }
101121   }
101122 }
101123
101124
101125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
101126   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101127   Dali::Devel::PixelBuffer arg2 ;
101128   float arg3 ;
101129   Dali::Devel::PixelBuffer *argp2 ;
101130
101131   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101132   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101133   if (!argp2) {
101134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101135     return ;
101136   }
101137   arg2 = *argp2;
101138   arg3 = (float)jarg3;
101139   {
101140     try {
101141       (arg1)->ApplyMask(arg2,arg3);
101142     } catch (std::out_of_range& e) {
101143       {
101144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101145       };
101146     } catch (std::exception& e) {
101147       {
101148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101149       };
101150     } catch (...) {
101151       {
101152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101153       };
101154     }
101155   }
101156 }
101157
101158
101159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
101160   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101161   Dali::Devel::PixelBuffer arg2 ;
101162   Dali::Devel::PixelBuffer *argp2 ;
101163
101164   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101165   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101166   if (!argp2) {
101167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101168     return ;
101169   }
101170   arg2 = *argp2;
101171   {
101172     try {
101173       (arg1)->ApplyMask(arg2);
101174     } catch (std::out_of_range& e) {
101175       {
101176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101177       };
101178     } catch (std::exception& e) {
101179       {
101180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101181       };
101182     } catch (...) {
101183       {
101184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101185       };
101186     }
101187   }
101188 }
101189
101190
101191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
101192   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101193   float arg2 ;
101194
101195   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101196   arg2 = (float)jarg2;
101197   {
101198     try {
101199       (arg1)->ApplyGaussianBlur(arg2);
101200     } catch (std::out_of_range& e) {
101201       {
101202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101203       };
101204     } catch (std::exception& e) {
101205       {
101206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101207       };
101208     } catch (...) {
101209       {
101210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101211       };
101212     }
101213   }
101214 }
101215
101216
101217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
101218   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101219   uint16_t arg2 ;
101220   uint16_t arg3 ;
101221   uint16_t arg4 ;
101222   uint16_t arg5 ;
101223
101224   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101225   arg2 = (uint16_t)jarg2;
101226   arg3 = (uint16_t)jarg3;
101227   arg4 = (uint16_t)jarg4;
101228   arg5 = (uint16_t)jarg5;
101229   {
101230     try {
101231       (arg1)->Crop(arg2,arg3,arg4,arg5);
101232     } catch (std::out_of_range& e) {
101233       {
101234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101235       };
101236     } catch (std::exception& e) {
101237       {
101238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101239       };
101240     } catch (...) {
101241       {
101242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101243       };
101244     }
101245   }
101246 }
101247
101248
101249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
101250   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101251   uint16_t arg2 ;
101252   uint16_t arg3 ;
101253
101254   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101255   arg2 = (uint16_t)jarg2;
101256   arg3 = (uint16_t)jarg3;
101257   {
101258     try {
101259       (arg1)->Resize(arg2,arg3);
101260     } catch (std::out_of_range& e) {
101261       {
101262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101263       };
101264     } catch (std::exception& e) {
101265       {
101266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101267       };
101268     } catch (...) {
101269       {
101270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101271       };
101272     }
101273   }
101274 }
101275
101276
101277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101278   void * jresult ;
101279   std::string *arg1 = 0 ;
101280   Dali::ImageDimensions arg2 ;
101281   Dali::FittingMode::Type arg3 ;
101282   Dali::SamplingMode::Type arg4 ;
101283   bool arg5 ;
101284   Dali::ImageDimensions *argp2 ;
101285   Dali::Devel::PixelBuffer result;
101286
101287   if (!jarg1) {
101288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101289     return 0;
101290   }
101291   std::string arg1_str(jarg1);
101292   arg1 = &arg1_str;
101293   argp2 = (Dali::ImageDimensions *)jarg2;
101294   if (!argp2) {
101295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101296     return 0;
101297   }
101298   arg2 = *argp2;
101299   arg3 = (Dali::FittingMode::Type)jarg3;
101300   arg4 = (Dali::SamplingMode::Type)jarg4;
101301   arg5 = jarg5 ? true : false;
101302   {
101303     try {
101304       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101305     } catch (std::out_of_range& e) {
101306       {
101307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101308       };
101309     } catch (std::exception& e) {
101310       {
101311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101312       };
101313     } catch (...) {
101314       {
101315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101316       };
101317     }
101318   }
101319   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101320
101321   return jresult;
101322 }
101323
101324
101325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101326   void * jresult ;
101327   std::string *arg1 = 0 ;
101328   Dali::ImageDimensions arg2 ;
101329   Dali::FittingMode::Type arg3 ;
101330   Dali::SamplingMode::Type arg4 ;
101331   Dali::ImageDimensions *argp2 ;
101332   Dali::Devel::PixelBuffer result;
101333
101334   if (!jarg1) {
101335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101336     return 0;
101337   }
101338   std::string arg1_str(jarg1);
101339   arg1 = &arg1_str;
101340   argp2 = (Dali::ImageDimensions *)jarg2;
101341   if (!argp2) {
101342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101343     return 0;
101344   }
101345   arg2 = *argp2;
101346   arg3 = (Dali::FittingMode::Type)jarg3;
101347   arg4 = (Dali::SamplingMode::Type)jarg4;
101348   {
101349     try {
101350       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
101351     } catch (std::out_of_range& e) {
101352       {
101353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101354       };
101355     } catch (std::exception& e) {
101356       {
101357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101358       };
101359     } catch (...) {
101360       {
101361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101362       };
101363     }
101364   }
101365   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101366
101367   return jresult;
101368 }
101369
101370
101371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101372   void * jresult ;
101373   std::string *arg1 = 0 ;
101374   Dali::ImageDimensions arg2 ;
101375   Dali::FittingMode::Type arg3 ;
101376   Dali::ImageDimensions *argp2 ;
101377   Dali::Devel::PixelBuffer result;
101378
101379   if (!jarg1) {
101380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101381     return 0;
101382   }
101383   std::string arg1_str(jarg1);
101384   arg1 = &arg1_str;
101385   argp2 = (Dali::ImageDimensions *)jarg2;
101386   if (!argp2) {
101387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101388     return 0;
101389   }
101390   arg2 = *argp2;
101391   arg3 = (Dali::FittingMode::Type)jarg3;
101392   {
101393     try {
101394       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
101395     } catch (std::out_of_range& e) {
101396       {
101397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101398       };
101399     } catch (std::exception& e) {
101400       {
101401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101402       };
101403     } catch (...) {
101404       {
101405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101406       };
101407     }
101408   }
101409   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101410
101411   return jresult;
101412 }
101413
101414
101415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
101416   void * jresult ;
101417   std::string *arg1 = 0 ;
101418   Dali::ImageDimensions arg2 ;
101419   Dali::ImageDimensions *argp2 ;
101420   Dali::Devel::PixelBuffer result;
101421
101422   if (!jarg1) {
101423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101424     return 0;
101425   }
101426   std::string arg1_str(jarg1);
101427   arg1 = &arg1_str;
101428   argp2 = (Dali::ImageDimensions *)jarg2;
101429   if (!argp2) {
101430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101431     return 0;
101432   }
101433   arg2 = *argp2;
101434   {
101435     try {
101436       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
101437     } catch (std::out_of_range& e) {
101438       {
101439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101440       };
101441     } catch (std::exception& e) {
101442       {
101443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101444       };
101445     } catch (...) {
101446       {
101447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101448       };
101449     }
101450   }
101451   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101452
101453   return jresult;
101454 }
101455
101456
101457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
101458   void * jresult ;
101459   std::string *arg1 = 0 ;
101460   Dali::Devel::PixelBuffer result;
101461
101462   if (!jarg1) {
101463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101464     return 0;
101465   }
101466   std::string arg1_str(jarg1);
101467   arg1 = &arg1_str;
101468   {
101469     try {
101470       result = Dali::LoadImageFromFile((std::string const &)*arg1);
101471     } catch (std::out_of_range& e) {
101472       {
101473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101474       };
101475     } catch (std::exception& e) {
101476       {
101477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101478       };
101479     } catch (...) {
101480       {
101481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101482       };
101483     }
101484   }
101485   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101486
101487   return jresult;
101488 }
101489
101490
101491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101492   void * jresult ;
101493   std::string *arg1 = 0 ;
101494   Dali::ImageDimensions arg2 ;
101495   Dali::FittingMode::Type arg3 ;
101496   Dali::SamplingMode::Type arg4 ;
101497   bool arg5 ;
101498   Dali::ImageDimensions *argp2 ;
101499   Dali::ImageDimensions result;
101500
101501   if (!jarg1) {
101502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101503     return 0;
101504   }
101505   std::string arg1_str(jarg1);
101506   arg1 = &arg1_str;
101507   argp2 = (Dali::ImageDimensions *)jarg2;
101508   if (!argp2) {
101509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101510     return 0;
101511   }
101512   arg2 = *argp2;
101513   arg3 = (Dali::FittingMode::Type)jarg3;
101514   arg4 = (Dali::SamplingMode::Type)jarg4;
101515   arg5 = jarg5 ? true : false;
101516   {
101517     try {
101518       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101519     } catch (std::out_of_range& e) {
101520       {
101521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101522       };
101523     } catch (std::exception& e) {
101524       {
101525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101526       };
101527     } catch (...) {
101528       {
101529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101530       };
101531     }
101532   }
101533   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101534
101535   return jresult;
101536 }
101537
101538
101539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101540   void * jresult ;
101541   std::string *arg1 = 0 ;
101542   Dali::ImageDimensions arg2 ;
101543   Dali::FittingMode::Type arg3 ;
101544   Dali::SamplingMode::Type arg4 ;
101545   Dali::ImageDimensions *argp2 ;
101546   Dali::ImageDimensions result;
101547
101548   if (!jarg1) {
101549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101550     return 0;
101551   }
101552   std::string arg1_str(jarg1);
101553   arg1 = &arg1_str;
101554   argp2 = (Dali::ImageDimensions *)jarg2;
101555   if (!argp2) {
101556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101557     return 0;
101558   }
101559   arg2 = *argp2;
101560   arg3 = (Dali::FittingMode::Type)jarg3;
101561   arg4 = (Dali::SamplingMode::Type)jarg4;
101562   {
101563     try {
101564       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
101565     } catch (std::out_of_range& e) {
101566       {
101567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101568       };
101569     } catch (std::exception& e) {
101570       {
101571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101572       };
101573     } catch (...) {
101574       {
101575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101576       };
101577     }
101578   }
101579   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101580
101581   return jresult;
101582 }
101583
101584
101585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101586   void * jresult ;
101587   std::string *arg1 = 0 ;
101588   Dali::ImageDimensions arg2 ;
101589   Dali::FittingMode::Type arg3 ;
101590   Dali::ImageDimensions *argp2 ;
101591   Dali::ImageDimensions result;
101592
101593   if (!jarg1) {
101594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101595     return 0;
101596   }
101597   std::string arg1_str(jarg1);
101598   arg1 = &arg1_str;
101599   argp2 = (Dali::ImageDimensions *)jarg2;
101600   if (!argp2) {
101601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101602     return 0;
101603   }
101604   arg2 = *argp2;
101605   arg3 = (Dali::FittingMode::Type)jarg3;
101606   {
101607     try {
101608       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
101609     } catch (std::out_of_range& e) {
101610       {
101611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101612       };
101613     } catch (std::exception& e) {
101614       {
101615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101616       };
101617     } catch (...) {
101618       {
101619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101620       };
101621     }
101622   }
101623   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101624
101625   return jresult;
101626 }
101627
101628
101629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
101630   void * jresult ;
101631   std::string *arg1 = 0 ;
101632   Dali::ImageDimensions arg2 ;
101633   Dali::ImageDimensions *argp2 ;
101634   Dali::ImageDimensions result;
101635
101636   if (!jarg1) {
101637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101638     return 0;
101639   }
101640   std::string arg1_str(jarg1);
101641   arg1 = &arg1_str;
101642   argp2 = (Dali::ImageDimensions *)jarg2;
101643   if (!argp2) {
101644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101645     return 0;
101646   }
101647   arg2 = *argp2;
101648   {
101649     try {
101650       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
101651     } catch (std::out_of_range& e) {
101652       {
101653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101654       };
101655     } catch (std::exception& e) {
101656       {
101657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101658       };
101659     } catch (...) {
101660       {
101661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101662       };
101663     }
101664   }
101665   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101666
101667   return jresult;
101668 }
101669
101670
101671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
101672   void * jresult ;
101673   std::string *arg1 = 0 ;
101674   Dali::ImageDimensions result;
101675
101676   if (!jarg1) {
101677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101678     return 0;
101679   }
101680   std::string arg1_str(jarg1);
101681   arg1 = &arg1_str;
101682   {
101683     try {
101684       result = Dali::GetClosestImageSize((std::string const &)*arg1);
101685     } catch (std::out_of_range& e) {
101686       {
101687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101688       };
101689     } catch (std::exception& e) {
101690       {
101691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101692       };
101693     } catch (...) {
101694       {
101695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101696       };
101697     }
101698   }
101699   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101700
101701   return jresult;
101702 }
101703
101704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
101705   void * jresult ;
101706   std::string *arg1 = 0 ;
101707   Dali::ImageDimensions result;
101708
101709   if (!jarg1) {
101710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101711     return 0;
101712   }
101713   std::string arg1_str(jarg1);
101714   arg1 = &arg1_str;
101715   {
101716     try {
101717       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
101718     } catch (std::out_of_range& e) {
101719       {
101720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101721       };
101722     } catch (std::exception& e) {
101723       {
101724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101725       };
101726     } catch (...) {
101727       {
101728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101729       };
101730     }
101731   }
101732   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101733
101734   return jresult;
101735 }
101736
101737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101738   void * jresult ;
101739   std::string *arg1 = 0 ;
101740   Dali::ImageDimensions arg2 ;
101741   Dali::FittingMode::Type arg3 ;
101742   Dali::SamplingMode::Type arg4 ;
101743   bool arg5 ;
101744   Dali::ImageDimensions *argp2 ;
101745   Dali::Devel::PixelBuffer result;
101746
101747   if (!jarg1) {
101748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101749     return 0;
101750   }
101751   std::string arg1_str(jarg1);
101752   arg1 = &arg1_str;
101753   argp2 = (Dali::ImageDimensions *)jarg2;
101754   if (!argp2) {
101755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101756     return 0;
101757   }
101758   arg2 = *argp2;
101759   arg3 = (Dali::FittingMode::Type)jarg3;
101760   arg4 = (Dali::SamplingMode::Type)jarg4;
101761   arg5 = jarg5 ? true : false;
101762   {
101763     try {
101764       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101765     } catch (std::out_of_range& e) {
101766       {
101767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101768       };
101769     } catch (std::exception& e) {
101770       {
101771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101772       };
101773     } catch (...) {
101774       {
101775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101776       };
101777     }
101778   }
101779   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101780
101781   return jresult;
101782 }
101783
101784
101785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101786   void * jresult ;
101787   std::string *arg1 = 0 ;
101788   Dali::ImageDimensions arg2 ;
101789   Dali::FittingMode::Type arg3 ;
101790   Dali::SamplingMode::Type arg4 ;
101791   Dali::ImageDimensions *argp2 ;
101792   Dali::Devel::PixelBuffer result;
101793
101794   if (!jarg1) {
101795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101796     return 0;
101797   }
101798   std::string arg1_str(jarg1);
101799   arg1 = &arg1_str;
101800   argp2 = (Dali::ImageDimensions *)jarg2;
101801   if (!argp2) {
101802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101803     return 0;
101804   }
101805   arg2 = *argp2;
101806   arg3 = (Dali::FittingMode::Type)jarg3;
101807   arg4 = (Dali::SamplingMode::Type)jarg4;
101808   {
101809     try {
101810       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
101811     } catch (std::out_of_range& e) {
101812       {
101813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101814       };
101815     } catch (std::exception& e) {
101816       {
101817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101818       };
101819     } catch (...) {
101820       {
101821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101822       };
101823     }
101824   }
101825   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101826
101827   return jresult;
101828 }
101829
101830
101831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101832   void * jresult ;
101833   std::string *arg1 = 0 ;
101834   Dali::ImageDimensions arg2 ;
101835   Dali::FittingMode::Type arg3 ;
101836   Dali::ImageDimensions *argp2 ;
101837   Dali::Devel::PixelBuffer result;
101838
101839   if (!jarg1) {
101840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101841     return 0;
101842   }
101843   std::string arg1_str(jarg1);
101844   arg1 = &arg1_str;
101845   argp2 = (Dali::ImageDimensions *)jarg2;
101846   if (!argp2) {
101847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101848     return 0;
101849   }
101850   arg2 = *argp2;
101851   arg3 = (Dali::FittingMode::Type)jarg3;
101852   {
101853     try {
101854       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
101855     } catch (std::out_of_range& e) {
101856       {
101857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101858       };
101859     } catch (std::exception& e) {
101860       {
101861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101862       };
101863     } catch (...) {
101864       {
101865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101866       };
101867     }
101868   }
101869   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101870
101871   return jresult;
101872 }
101873
101874
101875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
101876   void * jresult ;
101877   std::string *arg1 = 0 ;
101878   Dali::ImageDimensions arg2 ;
101879   Dali::ImageDimensions *argp2 ;
101880   Dali::Devel::PixelBuffer result;
101881
101882   if (!jarg1) {
101883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101884     return 0;
101885   }
101886   std::string arg1_str(jarg1);
101887   arg1 = &arg1_str;
101888   argp2 = (Dali::ImageDimensions *)jarg2;
101889   if (!argp2) {
101890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101891     return 0;
101892   }
101893   arg2 = *argp2;
101894   {
101895     try {
101896       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
101897     } catch (std::out_of_range& e) {
101898       {
101899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101900       };
101901     } catch (std::exception& e) {
101902       {
101903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101904       };
101905     } catch (...) {
101906       {
101907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101908       };
101909     }
101910   }
101911   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101912
101913   return jresult;
101914 }
101915
101916
101917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
101918   void * jresult ;
101919   std::string *arg1 = 0 ;
101920   Dali::Devel::PixelBuffer result;
101921
101922   if (!jarg1) {
101923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101924     return 0;
101925   }
101926   std::string arg1_str(jarg1);
101927   arg1 = &arg1_str;
101928   {
101929     try {
101930       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
101931     } catch (std::out_of_range& e) {
101932       {
101933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101934       };
101935     } catch (std::exception& e) {
101936       {
101937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101938       };
101939     } catch (...) {
101940       {
101941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101942       };
101943     }
101944   }
101945   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101946
101947   return jresult;
101948 }
101949
101950
101951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
101952   void * jresult ;
101953   Dali::Toolkit::WebView result;
101954
101955   {
101956     try {
101957       result = Dali::Toolkit::WebView::New();
101958     } catch (std::out_of_range& e) {
101959       {
101960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101961       };
101962     } catch (std::exception& e) {
101963       {
101964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101965       };
101966     } catch (Dali::DaliException e) {
101967       {
101968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101969       };
101970     } catch (...) {
101971       {
101972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101973       };
101974     }
101975   }
101976   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
101977   return jresult;
101978 }
101979
101980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
101981   void * jresult ;
101982   Dali::Toolkit::WebView result;
101983
101984   std::string *arg1;
101985   std::string *arg2;
101986
101987   if (!jarg1) {
101988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
101989     return 0;
101990   }
101991   if (!jarg2) {
101992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
101993     return 0;
101994   }
101995
101996   std::string jarg1_str = std::string(jarg1);
101997   std::string jarg2_str = std::string(jarg2);
101998
101999   arg1 = &jarg1_str;
102000   arg2 = &jarg2_str;
102001
102002   {
102003     try {
102004       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
102005     } catch (std::out_of_range& e) {
102006       {
102007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102008       };
102009     } catch (std::exception& e) {
102010       {
102011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102012       };
102013     } catch (Dali::DaliException e) {
102014       {
102015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102016       };
102017     } catch (...) {
102018       {
102019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102020       };
102021     }
102022   }
102023   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102024   return jresult;
102025 }
102026
102027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
102028   void * jresult ;
102029   Dali::Toolkit::WebView *arg1 = 0 ;
102030   Dali::Toolkit::WebView *result = 0 ;
102031
102032   arg1 = (Dali::Toolkit::WebView *)jarg1;
102033   if (!arg1) {
102034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102035     return 0;
102036   }
102037   {
102038     try {
102039       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
102040     } catch (std::out_of_range& e) {
102041       {
102042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102043       };
102044     } catch (std::exception& e) {
102045       {
102046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102047       };
102048     } catch (Dali::DaliException e) {
102049       {
102050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102051       };
102052     } catch (...) {
102053       {
102054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102055       };
102056     }
102057   }
102058   jresult = (void *)result;
102059   return jresult;
102060 }
102061
102062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
102063   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102064   arg1 = (Dali::Toolkit::WebView *)jarg1;
102065   {
102066     try {
102067       delete arg1;
102068     } catch (std::out_of_range& e) {
102069       {
102070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102071       };
102072     } catch (std::exception& e) {
102073       {
102074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102075       };
102076     } catch (Dali::DaliException e) {
102077       {
102078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102079       };
102080     } catch (...) {
102081       {
102082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102083       };
102084     }
102085   }
102086 }
102087
102088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
102089   void * jresult ;
102090   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102091   Dali::Toolkit::WebView *arg2 = 0 ;
102092   Dali::Toolkit::WebView *result = 0 ;
102093
102094   arg1 = (Dali::Toolkit::WebView *)jarg1;
102095   arg2 = (Dali::Toolkit::WebView *)jarg2;
102096   if (!arg2) {
102097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102098     return 0;
102099   }
102100   {
102101     try {
102102       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
102103     } catch (std::out_of_range& e) {
102104       {
102105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102106       };
102107     } catch (std::exception& e) {
102108       {
102109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102110       };
102111     } catch (Dali::DaliException e) {
102112       {
102113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102114       };
102115     } catch (...) {
102116       {
102117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102118       };
102119     }
102120   }
102121   jresult = (void *)result;
102122   return jresult;
102123 }
102124
102125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
102126   void * jresult ;
102127   Dali::BaseHandle arg1 ;
102128   Dali::BaseHandle *argp1 ;
102129   Dali::Toolkit::WebView result;
102130
102131   argp1 = (Dali::BaseHandle *)jarg1;
102132   if (!argp1) {
102133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
102134     return 0;
102135   }
102136   arg1 = *argp1;
102137   {
102138     try {
102139       result = Dali::Toolkit::WebView::DownCast(arg1);
102140     } catch (std::out_of_range& e) {
102141       {
102142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102143       };
102144     } catch (std::exception& e) {
102145       {
102146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102147       };
102148     } catch (Dali::DaliException e) {
102149       {
102150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102151       };
102152     } catch (...) {
102153       {
102154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102155       };
102156     }
102157   }
102158   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102159   return jresult;
102160 }
102161
102162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
102163   return (int) Dali::Toolkit::WebView::Property::URL;
102164 }
102165
102166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
102167   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
102168 }
102169
102170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
102171   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
102172 }
102173
102174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
102175   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
102176 }
102177
102178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
102179   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
102180 }
102181
102182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
102183   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
102184 }
102185
102186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
102187   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
102188 }
102189
102190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
102191   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
102192 }
102193
102194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
102195   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102196   std::string *arg2;
102197
102198   arg1 = (Dali::Toolkit::WebView *)jarg1;
102199
102200   if (!jarg2) {
102201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102202     return;
102203   }
102204
102205   std::string jarg2str = std::string(jarg2);
102206   arg2 = &jarg2str;
102207   {
102208     try {
102209       (arg1)->LoadUrl((std::string const &)*arg2);
102210     } catch (std::out_of_range& e) {
102211       {
102212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102213       };
102214     } catch (std::exception& e) {
102215       {
102216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102217       };
102218     } catch (Dali::DaliException e) {
102219       {
102220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102221       };
102222     } catch (...) {
102223       {
102224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102225       };
102226     }
102227   }
102228 }
102229
102230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
102231   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102232   std::string *arg2;
102233
102234   arg1 = (Dali::Toolkit::WebView *)jarg1;
102235   if (!jarg2) {
102236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102237     return;
102238   }
102239   std::string jarg2str = std::string(jarg2);
102240   arg2 = &jarg2str;
102241   {
102242     try {
102243       (arg1)->LoadHTMLString((std::string const &)*arg2);
102244     } catch (std::out_of_range& e) {
102245       {
102246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102247       };
102248     } catch (std::exception& e) {
102249       {
102250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102251       };
102252     } catch (Dali::DaliException e) {
102253       {
102254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102255       };
102256     } catch (...) {
102257       {
102258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102259       };
102260     }
102261   }
102262 }
102263
102264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
102265   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102266
102267   arg1 = (Dali::Toolkit::WebView *)jarg1;
102268   {
102269     try {
102270       (arg1)->Reload();
102271     } catch (std::out_of_range& e) {
102272       {
102273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102274       };
102275     } catch (std::exception& e) {
102276       {
102277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102278       };
102279     } catch (Dali::DaliException e) {
102280       {
102281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102282       };
102283     } catch (...) {
102284       {
102285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102286       };
102287     }
102288   }
102289 }
102290
102291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
102292   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102293
102294   arg1 = (Dali::Toolkit::WebView *)jarg1;
102295   {
102296     try {
102297       (arg1)->StopLoading();
102298     } catch (std::out_of_range& e) {
102299       {
102300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102301       };
102302     } catch (std::exception& e) {
102303       {
102304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102305       };
102306     } catch (Dali::DaliException e) {
102307       {
102308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102309       };
102310     } catch (...) {
102311       {
102312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102313       };
102314     }
102315   }
102316 }
102317
102318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
102319   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102320
102321   arg1 = (Dali::Toolkit::WebView *)jarg1;
102322   {
102323     try {
102324       (arg1)->Suspend();
102325     } catch (std::out_of_range& e) {
102326       {
102327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102328       };
102329     } catch (std::exception& e) {
102330       {
102331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102332       };
102333     } catch (Dali::DaliException e) {
102334       {
102335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102336       };
102337     } catch (...) {
102338       {
102339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102340       };
102341     }
102342   }
102343 }
102344
102345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
102346   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102347
102348   arg1 = (Dali::Toolkit::WebView *)jarg1;
102349   {
102350     try {
102351       (arg1)->Resume();
102352     } catch (std::out_of_range& e) {
102353       {
102354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102355       };
102356     } catch (std::exception& e) {
102357       {
102358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102359       };
102360     } catch (Dali::DaliException e) {
102361       {
102362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102363       };
102364     } catch (...) {
102365       {
102366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102367       };
102368     }
102369   }
102370 }
102371
102372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
102373   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102374
102375   arg1 = (Dali::Toolkit::WebView *)jarg1;
102376   {
102377     try {
102378       (arg1)->GoBack();
102379     } catch (std::out_of_range& e) {
102380       {
102381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102382       };
102383     } catch (std::exception& e) {
102384       {
102385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102386       };
102387     } catch (Dali::DaliException e) {
102388       {
102389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102390       };
102391     } catch (...) {
102392       {
102393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102394       };
102395     }
102396   }
102397 }
102398
102399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
102400   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102401
102402   arg1 = (Dali::Toolkit::WebView *)jarg1;
102403   {
102404     try {
102405       (arg1)->GoForward();
102406     } catch (std::out_of_range& e) {
102407       {
102408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102409       };
102410     } catch (std::exception& e) {
102411       {
102412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102413       };
102414     } catch (Dali::DaliException e) {
102415       {
102416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102417       };
102418     } catch (...) {
102419       {
102420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102421       };
102422     }
102423   }
102424 }
102425
102426 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
102427   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102428   bool ret;
102429
102430   arg1 = (Dali::Toolkit::WebView *)jarg1;
102431   {
102432     try {
102433       ret = (arg1)->CanGoBack();
102434     } catch (std::out_of_range& e) {
102435       {
102436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
102437       };
102438     } catch (std::exception& e) {
102439       {
102440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
102441       };
102442     } catch (Dali::DaliException e) {
102443       {
102444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
102445       };
102446     } catch (...) {
102447       {
102448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
102449       };
102450     }
102451   }
102452   return ret;
102453 }
102454
102455 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
102456   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102457   bool ret;
102458
102459   arg1 = (Dali::Toolkit::WebView *)jarg1;
102460   {
102461     try {
102462       ret = (arg1)->CanGoForward();
102463     } catch (std::out_of_range& e) {
102464       {
102465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
102466       };
102467     } catch (std::exception& e) {
102468       {
102469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
102470       };
102471     } catch (Dali::DaliException e) {
102472       {
102473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
102474       };
102475     } catch (...) {
102476       {
102477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
102478       };
102479     }
102480   }
102481   return ret;
102482 }
102483
102484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
102485   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102486   std::string *arg2;
102487
102488   arg1 = (Dali::Toolkit::WebView *)jarg1;
102489   if (!jarg2) {
102490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102491     return;
102492   }
102493   std::string jarg2_str = std::string(jarg2);
102494   arg2 = &jarg2_str;
102495
102496   {
102497     try {
102498       if (jarg3) {
102499         void (*handler)(char*) = (void (*)(char*)) jarg3;
102500         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
102501           handler(SWIG_csharp_string_callback(result.c_str()));
102502         });
102503       } else {
102504         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
102505       }
102506     } catch (std::out_of_range& e) {
102507       {
102508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102509       };
102510     } catch (std::exception& e) {
102511       {
102512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102513       };
102514     } catch (Dali::DaliException e) {
102515       {
102516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102517       };
102518     } catch (...) {
102519       {
102520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102521       };
102522     }
102523   }
102524 }
102525
102526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
102527 {
102528   if (!jarg2) {
102529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102530     return;
102531   }
102532
102533   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102534   std::string exposedObjectName = jarg2;
102535   void (*handler)(char*) = (void (*)(char*)) jarg3;
102536
102537   {
102538     try {
102539       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
102540         handler(SWIG_csharp_string_callback(message.c_str()));
102541       });
102542     } catch (std::out_of_range& e) {
102543       {
102544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102545       };
102546     } catch (std::exception& e) {
102547       {
102548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102549       };
102550     } catch (Dali::DaliException e) {
102551       {
102552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102553       };
102554     } catch (...) {
102555       {
102556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102557       };
102558     }
102559   }
102560 }
102561
102562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
102563   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102564
102565   arg1 = (Dali::Toolkit::WebView *)jarg1;
102566   {
102567     try {
102568       (arg1)->ClearHistory();
102569     } catch (std::out_of_range& e) {
102570       {
102571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102572       };
102573     } catch (std::exception& e) {
102574       {
102575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102576       };
102577     } catch (Dali::DaliException e) {
102578       {
102579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102580       };
102581     } catch (...) {
102582       {
102583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102584       };
102585     }
102586   }
102587 }
102588
102589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
102590   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102591
102592   arg1 = (Dali::Toolkit::WebView *)jarg1;
102593   {
102594     try {
102595       (arg1)->ClearCache();
102596     } catch (std::out_of_range& e) {
102597       {
102598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102599       };
102600     } catch (std::exception& e) {
102601       {
102602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102603       };
102604     } catch (Dali::DaliException e) {
102605       {
102606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102607       };
102608     } catch (...) {
102609       {
102610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102611       };
102612     }
102613   }
102614 }
102615
102616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
102617   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102618
102619   arg1 = (Dali::Toolkit::WebView *)jarg1;
102620   {
102621     try {
102622       (arg1)->ClearCookies();
102623     } catch (std::out_of_range& e) {
102624       {
102625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102626       };
102627     } catch (std::exception& e) {
102628       {
102629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102630       };
102631     } catch (Dali::DaliException e) {
102632       {
102633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102634       };
102635     } catch (...) {
102636       {
102637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102638       };
102639     }
102640   }
102641 }
102642
102643 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
102644     return (Dali::Toolkit::Control *)jarg1;
102645 }
102646
102647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
102648   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102649   SignalConverter::WebViewPageLoadSignal* result = NULL;
102650   {
102651     try {
102652       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
102653     } catch (std::out_of_range& e) {
102654       {
102655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102656       };
102657     } catch (std::exception& e) {
102658       {
102659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102660       };
102661     } catch (Dali::DaliException e) {
102662       {
102663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102664       };
102665     } catch (...) {
102666       {
102667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102668       };
102669     }
102670   }
102671   return (void*) result;
102672 }
102673
102674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
102675   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102676   SignalConverter::WebViewPageLoadSignal* result = NULL;
102677   {
102678     try {
102679       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
102680     } catch (std::out_of_range& e) {
102681       {
102682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102683       };
102684     } catch (std::exception& e) {
102685       {
102686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102687       };
102688     } catch (Dali::DaliException e) {
102689       {
102690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102691       };
102692     } catch (...) {
102693       {
102694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102695       };
102696     }
102697   }
102698   return (void*) result;
102699 }
102700
102701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
102702 {
102703   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102704   {
102705     try {
102706       delete object;
102707     } catch (std::out_of_range& e) {
102708       {
102709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102710       };
102711     } catch (std::exception& e) {
102712       {
102713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102714       };
102715     } catch (Dali::DaliException e) {
102716       {
102717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102718       };
102719     } catch (...) {
102720       {
102721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102722       };
102723     }
102724   }
102725 }
102726
102727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
102728 {
102729   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102730   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102731   {
102732     try {
102733       proxy->Connect(callback);
102734     } catch (std::out_of_range& e) {
102735       {
102736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102737       };
102738     } catch (std::exception& e) {
102739       {
102740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102741       };
102742     } catch (Dali::DaliException e) {
102743       {
102744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102745       };
102746     } catch (...) {
102747       {
102748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102749       };
102750     }
102751   }
102752 }
102753
102754
102755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
102756   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102757   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102758   {
102759     try {
102760       proxy->Disconnect(callback);
102761     } catch (std::out_of_range& e) {
102762       {
102763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102764       };
102765     } catch (std::exception& e) {
102766       {
102767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102768       };
102769     } catch (Dali::DaliException e) {
102770       {
102771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102772       };
102773     } catch (...) {
102774       {
102775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102776       };
102777     }
102778   }
102779 }
102780
102781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
102782   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102783   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
102784   {
102785     try {
102786       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
102787     } catch (std::out_of_range& e) {
102788       {
102789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102790       };
102791     } catch (std::exception& e) {
102792       {
102793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102794       };
102795     } catch (Dali::DaliException e) {
102796       {
102797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102798       };
102799     } catch (...) {
102800       {
102801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102802       };
102803     }
102804   }
102805   return (void*) result;
102806 }
102807
102808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
102809 {
102810   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102811   {
102812     try {
102813       delete object;
102814     } catch (std::out_of_range& e) {
102815       {
102816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102817       };
102818     } catch (std::exception& e) {
102819       {
102820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102821       };
102822     } catch (Dali::DaliException e) {
102823       {
102824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102825       };
102826     } catch (...) {
102827       {
102828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102829       };
102830     }
102831   }
102832 }
102833
102834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
102835 {
102836   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102837   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
102838   {
102839     try {
102840       proxy->Connect(callback);
102841     } catch (std::out_of_range& e) {
102842       {
102843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102844       };
102845     } catch (std::exception& e) {
102846       {
102847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102848       };
102849     } catch (Dali::DaliException e) {
102850       {
102851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102852       };
102853     } catch (...) {
102854       {
102855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102856       };
102857     }
102858   }
102859 }
102860
102861
102862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
102863   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102864   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
102865   {
102866     try {
102867       proxy->Disconnect(callback);
102868     } catch (std::out_of_range& e) {
102869       {
102870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102871       };
102872     } catch (std::exception& e) {
102873       {
102874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102875       };
102876     } catch (Dali::DaliException e) {
102877       {
102878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102879       };
102880     } catch (...) {
102881       {
102882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102883       };
102884     }
102885   }
102886 }
102887
102888 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
102889   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
102890   char * jresult = SWIG_csharp_string_callback((const char *)result);
102891   return jresult;
102892 }
102893
102894 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
102895   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
102896   return result;
102897 }
102898
102899 #ifdef __cplusplus
102900 }
102901 #endif
102902